]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wrong caption for html window, cleanup
[wxWidgets.git] / wxPython / src / msw / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMoveEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[104]
2571 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNcPaintEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNotifyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxPCXHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNGHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNMHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialog swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPanel swig_types[117]
2584 #define SWIGTYPE_p_wxPaperSize swig_types[118]
2585 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[119]
2586 #define SWIGTYPE_p_wxPen swig_types[120]
2587 #define SWIGTYPE_p_wxPoint swig_types[121]
2588 #define SWIGTYPE_p_wxPopupWindow swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewCanvas swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewControlBar swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewFrame swig_types[125]
2592 #define SWIGTYPE_p_wxPrintData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialog swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialogData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintPreview swig_types[129]
2596 #define SWIGTYPE_p_wxPrinter swig_types[130]
2597 #define SWIGTYPE_p_wxProgressDialog swig_types[131]
2598 #define SWIGTYPE_p_wxPyApp swig_types[132]
2599 #define SWIGTYPE_p_wxPyCommandEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridTableBase swig_types[138]
2605 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[139]
2606 #define SWIGTYPE_p_wxPyImageHandler swig_types[140]
2607 #define SWIGTYPE_p_wxPyPanel swig_types[141]
2608 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintPreview swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintout swig_types[146]
2613 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[147]
2614 #define SWIGTYPE_p_wxPySizer swig_types[148]
2615 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[149]
2616 #define SWIGTYPE_p_wxPyVListBox swig_types[150]
2617 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPyValidator swig_types[152]
2619 #define SWIGTYPE_p_wxPyWindow swig_types[153]
2620 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[154]
2621 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[155]
2622 #define SWIGTYPE_p_wxRect swig_types[156]
2623 #define SWIGTYPE_p_wxSashEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[158]
2625 #define SWIGTYPE_p_wxSashWindow swig_types[159]
2626 #define SWIGTYPE_p_wxScrollEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrollWinEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrolledWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSetCursorEvent swig_types[163]
2630 #define SWIGTYPE_p_wxShowEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[165]
2632 #define SWIGTYPE_p_wxSize swig_types[166]
2633 #define SWIGTYPE_p_wxSizeEvent swig_types[167]
2634 #define SWIGTYPE_p_wxSizer swig_types[168]
2635 #define SWIGTYPE_p_wxSizerItem swig_types[169]
2636 #define SWIGTYPE_p_wxSplashScreen swig_types[170]
2637 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[171]
2638 #define SWIGTYPE_p_wxSplitterEvent swig_types[172]
2639 #define SWIGTYPE_p_wxSplitterWindow swig_types[173]
2640 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[174]
2641 #define SWIGTYPE_p_wxStatusBar swig_types[175]
2642 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[176]
2643 #define SWIGTYPE_p_wxString swig_types[177]
2644 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[178]
2645 #define SWIGTYPE_p_wxTIFFHandler swig_types[179]
2646 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[180]
2647 #define SWIGTYPE_p_wxTextEntryDialog swig_types[181]
2648 #define SWIGTYPE_p_wxTipWindow swig_types[182]
2649 #define SWIGTYPE_p_wxTopLevelWindow swig_types[183]
2650 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[184]
2651 #define SWIGTYPE_p_wxValidator swig_types[185]
2652 #define SWIGTYPE_p_wxVisualAttributes swig_types[186]
2653 #define SWIGTYPE_p_wxWindow swig_types[187]
2654 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[188]
2655 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[189]
2656 #define SWIGTYPE_p_wxXPMHandler swig_types[190]
2657 static swig_type_info *swig_types[192];
2658 static swig_module_info swig_module = {swig_types, 191, 0, 0, 0, 0};
2659 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2660 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2661
2662 /* -------- TYPES TABLE (END) -------- */
2663
2664 #if (PY_VERSION_HEX <= 0x02000000)
2665 # if !defined(SWIG_PYTHON_CLASSIC)
2666 # error "This python version requires to use swig with the '-classic' option"
2667 # endif
2668 #endif
2669 #if (PY_VERSION_HEX <= 0x02020000)
2670 # error "This python version requires to use swig with the '-nomodern' option"
2671 #endif
2672 #if (PY_VERSION_HEX <= 0x02020000)
2673 # error "This python version requires to use swig with the '-nomodernargs' option"
2674 #endif
2675 #ifndef METH_O
2676 # error "This python version requires to use swig with the '-nofastunpack' option"
2677 #endif
2678
2679 /*-----------------------------------------------
2680 @(target):= _grid.so
2681 ------------------------------------------------*/
2682 #define SWIG_init init_grid
2683
2684 #define SWIG_name "_grid"
2685
2686 #define SWIGVERSION 0x010329
2687
2688
2689 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2690 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2691
2692
2693 #include <stdexcept>
2694
2695
2696 namespace swig {
2697 class PyObject_ptr {
2698 protected:
2699 PyObject *_obj;
2700
2701 public:
2702 PyObject_ptr() :_obj(0)
2703 {
2704 }
2705
2706 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2707 {
2708 Py_XINCREF(_obj);
2709 }
2710
2711 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2712 {
2713 if (initial_ref) Py_XINCREF(_obj);
2714 }
2715
2716 PyObject_ptr & operator=(const PyObject_ptr& item)
2717 {
2718 Py_XINCREF(item._obj);
2719 Py_XDECREF(_obj);
2720 _obj = item._obj;
2721 return *this;
2722 }
2723
2724 ~PyObject_ptr()
2725 {
2726 Py_XDECREF(_obj);
2727 }
2728
2729 operator PyObject *() const
2730 {
2731 return _obj;
2732 }
2733
2734 PyObject *operator->() const
2735 {
2736 return _obj;
2737 }
2738 };
2739 }
2740
2741
2742 namespace swig {
2743 struct PyObject_var : PyObject_ptr {
2744 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2745
2746 PyObject_var & operator = (PyObject* obj)
2747 {
2748 Py_XDECREF(_obj);
2749 _obj = obj;
2750 return *this;
2751 }
2752 };
2753 }
2754
2755
2756 #include "wx/wxPython/wxPython.h"
2757 #include "wx/wxPython/pyclasses.h"
2758 #include "wx/wxPython/printfw.h"
2759
2760 #include <wx/grid.h>
2761 #include <wx/generic/gridctrl.h>
2762
2763
2764 static const wxString wxPyEmptyString(wxEmptyString);
2765 static const wxString wxPyGridNameStr(wxGridNameStr);
2766 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2767
2768
2769 #define wxPyMake_TEMPLATE(TYPE) \
2770 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2771 PyObject* target = NULL; \
2772 if (source) { \
2773 /* Check if there is already a pointer to a Python object in the \
2774 OOR data that we can use. */ \
2775 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2776 if (data) { \
2777 target = data->m_obj; \
2778 if (target) \
2779 Py_INCREF(target); \
2780 } \
2781 /* Otherwise make a new wrapper for it the old fashioned way and \
2782 give it the OOR treatment */ \
2783 if (! target) { \
2784 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2785 if (target) \
2786 source->SetClientObject(new wxPyOORClientData(target)); \
2787 } \
2788 } else { /* source was NULL so return None. */ \
2789 Py_INCREF(Py_None); target = Py_None; \
2790 } \
2791 return target; \
2792 } \
2793
2794
2795 wxPyMake_TEMPLATE(wxGridCellRenderer)
2796 wxPyMake_TEMPLATE(wxGridCellEditor)
2797 wxPyMake_TEMPLATE(wxGridCellAttr)
2798 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2799 wxPyMake_TEMPLATE(wxGridTableBase)
2800
2801
2802
2803 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2804 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2805 wxGridCellAttr* rval = NULL; \
2806 bool found; \
2807 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2808 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2809 PyObject* ro; \
2810 wxGridCellAttr* ptr; \
2811 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2812 if (ro) { \
2813 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2814 rval = ptr; \
2815 Py_DECREF(ro); \
2816 } \
2817 } \
2818 wxPyEndBlockThreads(blocked); \
2819 if (! found) \
2820 rval = PCLASS::CBNAME(a, b, c); \
2821 return rval; \
2822 }
2823
2824
2825 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2826 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2828 bool found; \
2829 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2830 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2831 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2832 Py_DECREF(obj); \
2833 } \
2834 wxPyEndBlockThreads(blocked); \
2835 if (! found) \
2836 PCLASS::CBNAME(attr, a, b); \
2837 }
2838
2839
2840
2841 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2842 void CBNAME(wxGridCellAttr *attr, int val) { \
2843 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2844 bool found; \
2845 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2846 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2847 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2848 Py_DECREF(obj); \
2849 } \
2850 wxPyEndBlockThreads(blocked); \
2851 if (! found) \
2852 PCLASS::CBNAME(attr, val); \
2853 }
2854
2855
2856
2857 #define PYCALLBACK_INT__pure(CBNAME) \
2858 int CBNAME() { \
2859 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2860 int rval = 0; \
2861 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2862 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2863 wxPyEndBlockThreads(blocked); \
2864 return rval; \
2865 }
2866
2867
2868
2869 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2870 bool CBNAME(int a, int b) { \
2871 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2872 bool rval = 0; \
2873 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2874 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2875 wxPyEndBlockThreads(blocked); \
2876 return rval; \
2877 }
2878
2879
2880 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2881 wxString CBNAME(int a, int b) { \
2882 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2883 wxString rval; \
2884 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2885 PyObject* ro; \
2886 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2887 if (ro) { \
2888 rval = Py2wxString(ro); \
2889 Py_DECREF(ro); \
2890 } \
2891 } \
2892 wxPyEndBlockThreads(blocked); \
2893 return rval; \
2894 }
2895
2896
2897 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2898 void CBNAME(int a, int b, const wxString& c) { \
2899 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2900 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2901 PyObject* s = wx2PyString(c); \
2902 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2903 Py_DECREF(s); \
2904 } \
2905 wxPyEndBlockThreads(blocked); \
2906 }
2907
2908
2909 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2910 wxString CBNAME(int a, int b) { \
2911 bool found; \
2912 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2913 wxString rval; \
2914 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2915 PyObject* ro; \
2916 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2917 if (ro) { \
2918 rval = Py2wxString(ro); \
2919 Py_DECREF(ro); \
2920 } \
2921 } \
2922 wxPyEndBlockThreads(blocked); \
2923 if (! found) \
2924 rval = PCLASS::CBNAME(a, b); \
2925 return rval; \
2926 }
2927
2928
2929 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2930 bool CBNAME(int a, int b, const wxString& c) { \
2931 bool rval = 0; \
2932 bool found; \
2933 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2934 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2935 PyObject* s = wx2PyString(c); \
2936 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2937 Py_DECREF(s); \
2938 } \
2939 wxPyEndBlockThreads(blocked); \
2940 if (! found) \
2941 rval = PCLASS::CBNAME(a,b,c); \
2942 return rval; \
2943 }
2944
2945
2946
2947
2948 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2949 long CBNAME(int a, int b) { \
2950 long rval; \
2951 bool found; \
2952 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2953 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2954 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2955 wxPyEndBlockThreads(blocked); \
2956 if (! found) \
2957 rval = PCLASS::CBNAME(a,b); \
2958 return rval; \
2959 }
2960
2961
2962 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2963 bool CBNAME(int a, int b) { \
2964 bool rval = 0; \
2965 bool found; \
2966 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2967 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2968 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2969 wxPyEndBlockThreads(blocked); \
2970 if (! found) \
2971 rval = PCLASS::CBNAME(a,b); \
2972 return rval; \
2973 }
2974
2975
2976
2977 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2978 double CBNAME(int a, int b) { \
2979 bool found; \
2980 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2981 double rval; \
2982 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2983 PyObject* ro; \
2984 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2985 if (ro) { \
2986 PyObject* str = PyObject_Str(ro); \
2987 rval = PyFloat_AsDouble(str); \
2988 Py_DECREF(ro); Py_DECREF(str); \
2989 } \
2990 } \
2991 wxPyEndBlockThreads(blocked); \
2992 if (! found) \
2993 rval = PCLASS::CBNAME(a, b); \
2994 return rval; \
2995 }
2996
2997
2998
2999 #define PYCALLBACK__(PCLASS, CBNAME) \
3000 void CBNAME() { \
3001 bool found; \
3002 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3003 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3004 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3005 wxPyEndBlockThreads(blocked); \
3006 if (! found) \
3007 PCLASS::CBNAME(); \
3008 }
3009
3010
3011
3012 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3013 bool CBNAME(size_t a, size_t b) { \
3014 bool rval = 0; \
3015 bool found; \
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3017 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3018 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3019 wxPyEndBlockThreads(blocked); \
3020 if (! found) \
3021 rval = PCLASS::CBNAME(a,b); \
3022 return rval; \
3023 }
3024
3025
3026
3027 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3028 bool CBNAME(size_t a) { \
3029 bool rval = 0; \
3030 bool found; \
3031 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3032 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3033 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3034 wxPyEndBlockThreads(blocked); \
3035 if (! found) \
3036 rval = PCLASS::CBNAME(a); \
3037 return rval; \
3038 }
3039
3040
3041 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3042 wxString CBNAME(int a) { \
3043 bool found; \
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3045 wxString rval; \
3046 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3047 PyObject* ro; \
3048 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3049 if (ro) { \
3050 rval = Py2wxString(ro); \
3051 Py_DECREF(ro); \
3052 } \
3053 } \
3054 wxPyEndBlockThreads(blocked); \
3055 if (! found) \
3056 rval = PCLASS::CBNAME(a); \
3057 return rval; \
3058 }
3059
3060
3061 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3062 void CBNAME(int a, const wxString& c) { \
3063 bool found; \
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3065 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3066 PyObject* s = wx2PyString(c); \
3067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3068 Py_DECREF(s); \
3069 } \
3070 wxPyEndBlockThreads(blocked); \
3071 if (! found) \
3072 PCLASS::CBNAME(a,c); \
3073 }
3074
3075
3076
3077
3078 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3079 bool CBNAME() { \
3080 bool rval = 0; \
3081 bool found; \
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3083 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3084 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3085 wxPyEndBlockThreads(blocked); \
3086 if (! found) \
3087 rval = PCLASS::CBNAME(); \
3088 return rval; \
3089 }
3090
3091
3092
3093 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3094 void CBNAME(size_t a, int b) { \
3095 bool found; \
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3097 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3098 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3099 wxPyEndBlockThreads(blocked); \
3100 if (! found) \
3101 PCLASS::CBNAME(a,b); \
3102 }
3103
3104
3105
3106
3107 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3108 void CBNAME(int a, int b, long c) { \
3109 bool found; \
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3111 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3112 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3113 wxPyEndBlockThreads(blocked); \
3114 if (! found) \
3115 PCLASS::CBNAME(a,b,c); \
3116 }
3117
3118
3119
3120
3121 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3122 void CBNAME(int a, int b, double c) { \
3123 bool found; \
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3125 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3126 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3127 wxPyEndBlockThreads(blocked); \
3128 if (! found) \
3129 PCLASS::CBNAME(a,b,c); \
3130 }
3131
3132
3133
3134 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3135 void CBNAME(int a, int b, bool c) { \
3136 bool found; \
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3138 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3139 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3140 wxPyEndBlockThreads(blocked); \
3141 if (! found) \
3142 PCLASS::CBNAME(a,b,c); \
3143 }
3144
3145
3146
3147
3148
3149 SWIGINTERN swig_type_info*
3150 SWIG_pchar_descriptor()
3151 {
3152 static int init = 0;
3153 static swig_type_info* info = 0;
3154 if (!init) {
3155 info = SWIG_TypeQuery("_p_char");
3156 init = 1;
3157 }
3158 return info;
3159 }
3160
3161
3162 SWIGINTERNINLINE PyObject *
3163 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3164 {
3165 if (carray) {
3166 if (size > INT_MAX) {
3167 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3168 return pchar_descriptor ?
3169 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3170 } else {
3171 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3172 }
3173 } else {
3174 return SWIG_Py_Void();
3175 }
3176 }
3177
3178
3179 SWIGINTERNINLINE PyObject *
3180 SWIG_FromCharPtr(const char *cptr)
3181 {
3182 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3183 }
3184
3185
3186 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3187 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3188 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3189 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3190 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3191 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3192 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3193 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3194 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3195 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3196
3197
3198 #define SWIG_From_long PyInt_FromLong
3199
3200
3201 SWIGINTERNINLINE PyObject *
3202 SWIG_From_int (int value)
3203 {
3204 return SWIG_From_long (value);
3205 }
3206
3207 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3208 if (!self->GetClientObject())
3209 self->SetClientObject(new wxPyOORClientData(_self));
3210 }
3211 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3212 }
3213
3214 #include <limits.h>
3215 #ifndef LLONG_MIN
3216 # define LLONG_MIN LONG_LONG_MIN
3217 #endif
3218 #ifndef LLONG_MAX
3219 # define LLONG_MAX LONG_LONG_MAX
3220 #endif
3221 #ifndef ULLONG_MAX
3222 # define ULLONG_MAX ULONG_LONG_MAX
3223 #endif
3224
3225
3226 SWIGINTERN int
3227 SWIG_AsVal_long (PyObject* obj, long* val)
3228 {
3229 if (PyNumber_Check(obj)) {
3230 if (val) *val = PyInt_AsLong(obj);
3231 return SWIG_OK;
3232 }
3233 return SWIG_TypeError;
3234 }
3235
3236
3237 SWIGINTERN int
3238 SWIG_AsVal_int (PyObject * obj, int *val)
3239 {
3240 long v;
3241 int res = SWIG_AsVal_long (obj, &v);
3242 if (SWIG_IsOK(res)) {
3243 if ((v < INT_MIN || v > INT_MAX)) {
3244 return SWIG_OverflowError;
3245 } else {
3246 if (val) *val = static_cast< int >(v);
3247 }
3248 }
3249 return res;
3250 }
3251
3252
3253 SWIGINTERN int
3254 SWIG_AsVal_bool (PyObject *obj, bool *val)
3255 {
3256 if (obj == Py_True) {
3257 if (val) *val = true;
3258 return SWIG_OK;
3259 } else if (obj == Py_False) {
3260 if (val) *val = false;
3261 return SWIG_OK;
3262 } else {
3263 long v = 0;
3264 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3265 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3266 return res;
3267 }
3268 }
3269
3270
3271 class wxPyGridCellRenderer : public wxGridCellRenderer
3272 {
3273 public:
3274 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3275
3276 // Implement Python callback aware virtual methods
3277 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3278 wxDC& dc, const wxRect& rect,
3279 int row, int col, bool isSelected) {
3280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3281 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3282 PyObject* go = wxPyMake_wxObject(&grid,false);
3283 PyObject* dco = wxPyMake_wxObject(&dc,false);
3284 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3285 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3286
3287 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3288 row, col, isSelected));
3289 Py_DECREF(go);
3290 Py_DECREF(ao);
3291 Py_DECREF(dco);
3292 Py_DECREF(ro);
3293 }
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3298 int row, int col) {
3299 wxSize rval;
3300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3301 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3302 PyObject* ro;
3303 wxSize* ptr;
3304 PyObject* go = wxPyMake_wxObject(&grid,false);
3305 PyObject* dco = wxPyMake_wxObject(&dc,false);
3306 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3307
3308 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3309 go, ao, dco,
3310 row, col));
3311 Py_DECREF(go);
3312 Py_DECREF(ao);
3313 Py_DECREF(dco);
3314
3315 if (ro) {
3316 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3317 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3318 rval = *ptr;
3319 }
3320 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3321 PyObject* o1 = PySequence_GetItem(ro, 0);
3322 PyObject* o2 = PySequence_GetItem(ro, 1);
3323 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3324 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3325 else
3326 PyErr_SetString(PyExc_TypeError, errmsg);
3327 Py_DECREF(o1);
3328 Py_DECREF(o2);
3329 }
3330 else {
3331 PyErr_SetString(PyExc_TypeError, errmsg);
3332 }
3333 Py_DECREF(ro);
3334 }
3335 }
3336 wxPyEndBlockThreads(blocked);
3337 return rval;
3338 }
3339
3340
3341 wxGridCellRenderer *Clone() const {
3342 wxGridCellRenderer* rval = NULL;
3343 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3344 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3345 PyObject* ro;
3346 wxGridCellRenderer* ptr;
3347 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3348 if (ro) {
3349 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3350 rval = ptr;
3351 Py_DECREF(ro);
3352 }
3353 }
3354 wxPyEndBlockThreads(blocked);
3355 return rval;
3356 }
3357
3358 DEC_PYCALLBACK__STRING(SetParameters);
3359
3360 PYPRIVATE;
3361 };
3362
3363 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3364
3365
3366
3367 class wxPyGridCellEditor : public wxGridCellEditor
3368 {
3369 public:
3370 wxPyGridCellEditor() : wxGridCellEditor() {}
3371
3372 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3373 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3374 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3375 PyObject* po = wxPyMake_wxObject(parent,false);
3376 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3377
3378 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3379 Py_DECREF(po);
3380 Py_DECREF(eo);
3381 }
3382 wxPyEndBlockThreads(blocked);
3383 }
3384
3385
3386 void BeginEdit(int row, int col, wxGrid* grid) {
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3389 PyObject* go = wxPyMake_wxObject(grid,false);
3390 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3391 Py_DECREF(go);
3392 }
3393 wxPyEndBlockThreads(blocked);
3394 }
3395
3396
3397 bool EndEdit(int row, int col, wxGrid* grid) {
3398 bool rv = false;
3399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3400 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3401 PyObject* go = wxPyMake_wxObject(grid,false);
3402 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3403 Py_DECREF(go);
3404 }
3405 wxPyEndBlockThreads(blocked);
3406 return rv;
3407 }
3408
3409
3410 wxGridCellEditor* Clone() const {
3411 wxGridCellEditor* rval = NULL;
3412 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3413 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3414 PyObject* ro;
3415 wxGridCellEditor* ptr;
3416 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3417 if (ro) {
3418 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3419 rval = ptr;
3420 Py_DECREF(ro);
3421 }
3422 }
3423 wxPyEndBlockThreads(blocked);
3424 return rval;
3425 }
3426
3427
3428 void Show(bool show, wxGridCellAttr *attr) {
3429 bool found;
3430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3431 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3432 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3433 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3434 Py_DECREF(ao);
3435 }
3436 wxPyEndBlockThreads(blocked);
3437 if (! found)
3438 wxGridCellEditor::Show(show, attr);
3439 }
3440
3441
3442 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3443 bool found;
3444 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3445 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3446 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3447 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3448
3449 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3450
3451 Py_DECREF(ro);
3452 Py_DECREF(ao);
3453 }
3454 wxPyEndBlockThreads(blocked);
3455 if (! found)
3456 wxGridCellEditor::PaintBackground(rectCell, attr);
3457 }
3458
3459
3460 DEC_PYCALLBACK___pure(Reset);
3461 DEC_PYCALLBACK__constany(SetSize, wxRect);
3462 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3463 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3464 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3465 DEC_PYCALLBACK__(StartingClick);
3466 DEC_PYCALLBACK__(Destroy);
3467 DEC_PYCALLBACK__STRING(SetParameters);
3468 DEC_PYCALLBACK_STRING__constpure(GetValue);
3469
3470 PYPRIVATE;
3471 };
3472
3473
3474 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3475 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3476 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3477 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3478 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3479 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3480 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3481 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3482 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3483
3484
3485 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3486 if (!self->GetClientObject())
3487 self->SetClientObject(new wxPyOORClientData(_self));
3488 }
3489 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3490 }
3491 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3492 if (!self->GetClientObject())
3493 self->SetClientObject(new wxPyOORClientData(_self));
3494 }
3495
3496 SWIGINTERN int
3497 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3498 {
3499 long v = 0;
3500 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3501 return SWIG_TypeError;
3502 }
3503 else if (val)
3504 *val = (unsigned long)v;
3505 return SWIG_OK;
3506 }
3507
3508
3509 SWIGINTERNINLINE int
3510 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3511 {
3512 unsigned long v;
3513 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3514 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3515 return res;
3516 }
3517
3518
3519 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3520 {
3521 public:
3522 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3523
3524 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3525 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3526 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3527 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3528
3529 PYPRIVATE;
3530 };
3531
3532 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3533 if (!self->GetClientObject())
3534 self->SetClientObject(new wxPyOORClientData(_self));
3535 }
3536
3537 #define SWIG_From_double PyFloat_FromDouble
3538
3539
3540 SWIGINTERN int
3541 SWIG_AsVal_double (PyObject *obj, double* val)
3542 {
3543 if (PyNumber_Check(obj)) {
3544 if (val) *val = PyFloat_AsDouble(obj);
3545 return SWIG_OK;
3546 }
3547 return SWIG_TypeError;
3548 }
3549
3550
3551 class wxPyGridTableBase : public wxGridTableBase
3552 {
3553 public:
3554 wxPyGridTableBase() : wxGridTableBase() {}
3555
3556 PYCALLBACK_INT__pure(GetNumberRows);
3557 PYCALLBACK_INT__pure(GetNumberCols);
3558 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3559 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3560 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3561 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3562 PYCALLBACK__(wxGridTableBase, Clear);
3563 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3564 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3565 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3566 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3567 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3568 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3569 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3570 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3571 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3572 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3573 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3574 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3575 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3576 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3577 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3578
3579
3580 wxString GetValue(int row, int col) {
3581 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3582 wxString rval;
3583 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3584 PyObject* ro;
3585 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3586 if (ro) {
3587 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3588 PyObject* old = ro;
3589 ro = PyObject_Str(ro);
3590 Py_DECREF(old);
3591 }
3592 rval = Py2wxString(ro);
3593 Py_DECREF(ro);
3594 }
3595 }
3596 wxPyEndBlockThreads(blocked);
3597 return rval;
3598 }
3599
3600 void SetValue(int row, int col, const wxString& val) {
3601 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3602 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3603 PyObject* s = wx2PyString(val);
3604 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3605 Py_DECREF(s);
3606 }
3607 wxPyEndBlockThreads(blocked);
3608 }
3609
3610
3611 // Map the Get/Set methods for the standard non-string types to
3612 // the GetValue and SetValue python methods.
3613 long GetValueAsLong( int row, int col ) {
3614 long rval = 0;
3615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3616 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3617 PyObject* ro;
3618 PyObject* num;
3619 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3620 if (ro && PyNumber_Check(ro)) {
3621 num = PyNumber_Int(ro);
3622 if (num) {
3623 rval = PyInt_AsLong(num);
3624 Py_DECREF(num);
3625 }
3626 Py_DECREF(ro);
3627 }
3628 }
3629 wxPyEndBlockThreads(blocked);
3630 return rval;
3631 }
3632
3633 double GetValueAsDouble( int row, int col ) {
3634 double rval = 0.0;
3635 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3636 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3637 PyObject* ro;
3638 PyObject* num;
3639 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3640 if (ro && PyNumber_Check(ro)) {
3641 num = PyNumber_Float(ro);
3642 if (num) {
3643 rval = PyFloat_AsDouble(num);
3644 Py_DECREF(num);
3645 }
3646 Py_DECREF(ro);
3647 }
3648 }
3649 wxPyEndBlockThreads(blocked);
3650 return rval;
3651 }
3652
3653 bool GetValueAsBool( int row, int col ) {
3654 return (bool)GetValueAsLong(row, col);
3655 }
3656
3657 void SetValueAsLong( int row, int col, long value ) {
3658 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3659 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3660 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3661 }
3662 wxPyEndBlockThreads(blocked);
3663 }
3664
3665 void SetValueAsDouble( int row, int col, double value ) {
3666 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3667 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3668 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3669 }
3670 wxPyEndBlockThreads(blocked);
3671 }
3672
3673 void SetValueAsBool( int row, int col, bool value ) {
3674 SetValueAsLong( row, col, (long)value );
3675 }
3676
3677
3678 PYPRIVATE;
3679 };
3680
3681 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3682
3683 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3684
3685 if (source == Py_None) {
3686 **obj = wxGridCellCoords(-1,-1);
3687 return true;
3688 }
3689
3690 // If source is an object instance then it may already be the right type
3691 if (wxPySwigInstance_Check(source)) {
3692 wxGridCellCoords* ptr;
3693 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3694 goto error;
3695 *obj = ptr;
3696 return true;
3697 }
3698 // otherwise a 2-tuple of integers is expected
3699 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3700 PyObject* o1 = PySequence_GetItem(source, 0);
3701 PyObject* o2 = PySequence_GetItem(source, 1);
3702 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3703 Py_DECREF(o1);
3704 Py_DECREF(o2);
3705 goto error;
3706 }
3707 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3708 Py_DECREF(o1);
3709 Py_DECREF(o2);
3710 return true;
3711 }
3712
3713 error:
3714 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3715 return false;
3716 }
3717
3718
3719 bool wxGridCellCoords_typecheck(PyObject* source) {
3720 void* ptr;
3721
3722 if (wxPySwigInstance_Check(source) &&
3723 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3724 return true;
3725
3726 PyErr_Clear();
3727 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3728 return true;
3729
3730 return false;
3731 }
3732
3733
3734 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3735 {
3736 PyObject* list = PyList_New(0);
3737 size_t idx;
3738 for (idx = 0; idx < source.GetCount(); idx += 1) {
3739 wxGridCellCoords& coord = source.Item(idx);
3740 PyObject* tup = PyTuple_New(2);
3741 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3742 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3743 PyList_Append(list, tup);
3744 Py_DECREF(tup);
3745 }
3746 return list;
3747 }
3748
3749 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3750 wxGridCellCoords temp, *obj = &temp;
3751 if ( other == Py_None ) return false;
3752 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3753 PyErr_Clear();
3754 return false;
3755 }
3756 return self->operator==(*obj);
3757 }
3758 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3759 wxGridCellCoords temp, *obj = &temp;
3760 if ( other == Py_None ) return true;
3761 if ( ! wxGridCellCoords_helper(other, &obj)) {
3762 PyErr_Clear();
3763 return true;
3764 }
3765 return self->operator!=(*obj);
3766 }
3767 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3768 PyObject* tup = PyTuple_New(2);
3769 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3770 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3771 return tup;
3772 }
3773
3774 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3775
3776 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3777 wxGridCellCoords rv;
3778 self->XYToCell(x, y, rv);
3779 return rv;
3780 }
3781 #ifdef __cplusplus
3782 extern "C" {
3783 #endif
3784 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3785 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3786 return 1;
3787 }
3788
3789
3790 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3791 PyObject *pyobj = 0;
3792
3793 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3794 return pyobj;
3795 }
3796
3797
3798 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3799 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3800 return 1;
3801 }
3802
3803
3804 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3805 PyObject *pyobj = 0;
3806
3807 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3808 return pyobj;
3809 }
3810
3811
3812 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3813 PyObject *resultobj = 0;
3814 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3815 PyObject *arg2 = (PyObject *) 0 ;
3816 void *argp1 = 0 ;
3817 int res1 = 0 ;
3818 PyObject * obj0 = 0 ;
3819 PyObject * obj1 = 0 ;
3820 char * kwnames[] = {
3821 (char *) "self",(char *) "_self", NULL
3822 };
3823
3824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3826 if (!SWIG_IsOK(res1)) {
3827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3828 }
3829 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3830 arg2 = obj1;
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 wxGridCellWorker__setOORInfo(arg1,arg2);
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 resultobj = SWIG_Py_Void();
3838 return resultobj;
3839 fail:
3840 return NULL;
3841 }
3842
3843
3844 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3845 PyObject *resultobj = 0;
3846 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3847 void *argp1 = 0 ;
3848 int res1 = 0 ;
3849 PyObject *swig_obj[1] ;
3850
3851 if (!args) SWIG_fail;
3852 swig_obj[0] = args;
3853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3854 if (!SWIG_IsOK(res1)) {
3855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3856 }
3857 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 delete_wxGridCellWorker(arg1);
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 resultobj = SWIG_Py_Void();
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
3872 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3873 PyObject *resultobj = 0;
3874 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3875 wxString *arg2 = 0 ;
3876 void *argp1 = 0 ;
3877 int res1 = 0 ;
3878 bool temp2 = false ;
3879 PyObject * obj0 = 0 ;
3880 PyObject * obj1 = 0 ;
3881 char * kwnames[] = {
3882 (char *) "self",(char *) "params", NULL
3883 };
3884
3885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3887 if (!SWIG_IsOK(res1)) {
3888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3889 }
3890 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3891 {
3892 arg2 = wxString_in_helper(obj1);
3893 if (arg2 == NULL) SWIG_fail;
3894 temp2 = true;
3895 }
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 (arg1)->SetParameters((wxString const &)*arg2);
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 resultobj = SWIG_Py_Void();
3903 {
3904 if (temp2)
3905 delete arg2;
3906 }
3907 return resultobj;
3908 fail:
3909 {
3910 if (temp2)
3911 delete arg2;
3912 }
3913 return NULL;
3914 }
3915
3916
3917 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3918 PyObject *resultobj = 0;
3919 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3920 void *argp1 = 0 ;
3921 int res1 = 0 ;
3922 PyObject *swig_obj[1] ;
3923
3924 if (!args) SWIG_fail;
3925 swig_obj[0] = args;
3926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3927 if (!SWIG_IsOK(res1)) {
3928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3929 }
3930 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 (arg1)->IncRef();
3934 wxPyEndAllowThreads(__tstate);
3935 if (PyErr_Occurred()) SWIG_fail;
3936 }
3937 resultobj = SWIG_Py_Void();
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3945 PyObject *resultobj = 0;
3946 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3947 void *argp1 = 0 ;
3948 int res1 = 0 ;
3949 PyObject *swig_obj[1] ;
3950
3951 if (!args) SWIG_fail;
3952 swig_obj[0] = args;
3953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3954 if (!SWIG_IsOK(res1)) {
3955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3956 }
3957 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 (arg1)->DecRef();
3961 wxPyEndAllowThreads(__tstate);
3962 if (PyErr_Occurred()) SWIG_fail;
3963 }
3964 resultobj = SWIG_Py_Void();
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3972 PyObject *obj;
3973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3974 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3975 return SWIG_Py_Void();
3976 }
3977
3978 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj = 0;
3980 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3981 wxGrid *arg2 = 0 ;
3982 wxGridCellAttr *arg3 = 0 ;
3983 wxDC *arg4 = 0 ;
3984 wxRect *arg5 = 0 ;
3985 int arg6 ;
3986 int arg7 ;
3987 bool arg8 ;
3988 void *argp1 = 0 ;
3989 int res1 = 0 ;
3990 void *argp2 = 0 ;
3991 int res2 = 0 ;
3992 void *argp3 = 0 ;
3993 int res3 = 0 ;
3994 void *argp4 = 0 ;
3995 int res4 = 0 ;
3996 wxRect temp5 ;
3997 int val6 ;
3998 int ecode6 = 0 ;
3999 int val7 ;
4000 int ecode7 = 0 ;
4001 bool val8 ;
4002 int ecode8 = 0 ;
4003 PyObject * obj0 = 0 ;
4004 PyObject * obj1 = 0 ;
4005 PyObject * obj2 = 0 ;
4006 PyObject * obj3 = 0 ;
4007 PyObject * obj4 = 0 ;
4008 PyObject * obj5 = 0 ;
4009 PyObject * obj6 = 0 ;
4010 PyObject * obj7 = 0 ;
4011 char * kwnames[] = {
4012 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4013 };
4014
4015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4017 if (!SWIG_IsOK(res1)) {
4018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4019 }
4020 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4022 if (!SWIG_IsOK(res2)) {
4023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4024 }
4025 if (!argp2) {
4026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4027 }
4028 arg2 = reinterpret_cast< wxGrid * >(argp2);
4029 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4030 if (!SWIG_IsOK(res3)) {
4031 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4032 }
4033 if (!argp3) {
4034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4035 }
4036 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4037 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4038 if (!SWIG_IsOK(res4)) {
4039 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4040 }
4041 if (!argp4) {
4042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4043 }
4044 arg4 = reinterpret_cast< wxDC * >(argp4);
4045 {
4046 arg5 = &temp5;
4047 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4048 }
4049 ecode6 = SWIG_AsVal_int(obj5, &val6);
4050 if (!SWIG_IsOK(ecode6)) {
4051 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4052 }
4053 arg6 = static_cast< int >(val6);
4054 ecode7 = SWIG_AsVal_int(obj6, &val7);
4055 if (!SWIG_IsOK(ecode7)) {
4056 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4057 }
4058 arg7 = static_cast< int >(val7);
4059 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4060 if (!SWIG_IsOK(ecode8)) {
4061 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4062 }
4063 arg8 = static_cast< bool >(val8);
4064 {
4065 PyThreadState* __tstate = wxPyBeginAllowThreads();
4066 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4067 wxPyEndAllowThreads(__tstate);
4068 if (PyErr_Occurred()) SWIG_fail;
4069 }
4070 resultobj = SWIG_Py_Void();
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj = 0;
4079 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4080 wxGrid *arg2 = 0 ;
4081 wxGridCellAttr *arg3 = 0 ;
4082 wxDC *arg4 = 0 ;
4083 int arg5 ;
4084 int arg6 ;
4085 wxSize result;
4086 void *argp1 = 0 ;
4087 int res1 = 0 ;
4088 void *argp2 = 0 ;
4089 int res2 = 0 ;
4090 void *argp3 = 0 ;
4091 int res3 = 0 ;
4092 void *argp4 = 0 ;
4093 int res4 = 0 ;
4094 int val5 ;
4095 int ecode5 = 0 ;
4096 int val6 ;
4097 int ecode6 = 0 ;
4098 PyObject * obj0 = 0 ;
4099 PyObject * obj1 = 0 ;
4100 PyObject * obj2 = 0 ;
4101 PyObject * obj3 = 0 ;
4102 PyObject * obj4 = 0 ;
4103 PyObject * obj5 = 0 ;
4104 char * kwnames[] = {
4105 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4106 };
4107
4108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4110 if (!SWIG_IsOK(res1)) {
4111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4112 }
4113 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4115 if (!SWIG_IsOK(res2)) {
4116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4117 }
4118 if (!argp2) {
4119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4120 }
4121 arg2 = reinterpret_cast< wxGrid * >(argp2);
4122 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4123 if (!SWIG_IsOK(res3)) {
4124 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4125 }
4126 if (!argp3) {
4127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4128 }
4129 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4130 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4131 if (!SWIG_IsOK(res4)) {
4132 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4133 }
4134 if (!argp4) {
4135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4136 }
4137 arg4 = reinterpret_cast< wxDC * >(argp4);
4138 ecode5 = SWIG_AsVal_int(obj4, &val5);
4139 if (!SWIG_IsOK(ecode5)) {
4140 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4141 }
4142 arg5 = static_cast< int >(val5);
4143 ecode6 = SWIG_AsVal_int(obj5, &val6);
4144 if (!SWIG_IsOK(ecode6)) {
4145 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4146 }
4147 arg6 = static_cast< int >(val6);
4148 {
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4162 PyObject *resultobj = 0;
4163 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4164 wxGridCellRenderer *result = 0 ;
4165 void *argp1 = 0 ;
4166 int res1 = 0 ;
4167 PyObject *swig_obj[1] ;
4168
4169 if (!args) SWIG_fail;
4170 swig_obj[0] = args;
4171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4172 if (!SWIG_IsOK(res1)) {
4173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4174 }
4175 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4176 {
4177 PyThreadState* __tstate = wxPyBeginAllowThreads();
4178 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 {
4183 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4184 }
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4192 PyObject *obj;
4193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4194 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4195 return SWIG_Py_Void();
4196 }
4197
4198 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4199 PyObject *resultobj = 0;
4200 wxPyGridCellRenderer *result = 0 ;
4201
4202 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4203 {
4204 PyThreadState* __tstate = wxPyBeginAllowThreads();
4205 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj = 0;
4218 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4219 PyObject *arg2 = (PyObject *) 0 ;
4220 PyObject *arg3 = (PyObject *) 0 ;
4221 void *argp1 = 0 ;
4222 int res1 = 0 ;
4223 PyObject * obj0 = 0 ;
4224 PyObject * obj1 = 0 ;
4225 PyObject * obj2 = 0 ;
4226 char * kwnames[] = {
4227 (char *) "self",(char *) "self",(char *) "_class", NULL
4228 };
4229
4230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4232 if (!SWIG_IsOK(res1)) {
4233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4234 }
4235 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4236 arg2 = obj1;
4237 arg3 = obj2;
4238 {
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 (arg1)->_setCallbackInfo(arg2,arg3);
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 resultobj = SWIG_Py_Void();
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj = 0;
4253 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4254 wxString *arg2 = 0 ;
4255 void *argp1 = 0 ;
4256 int res1 = 0 ;
4257 bool temp2 = false ;
4258 PyObject * obj0 = 0 ;
4259 PyObject * obj1 = 0 ;
4260 char * kwnames[] = {
4261 (char *) "self",(char *) "params", NULL
4262 };
4263
4264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4266 if (!SWIG_IsOK(res1)) {
4267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4268 }
4269 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4270 {
4271 arg2 = wxString_in_helper(obj1);
4272 if (arg2 == NULL) SWIG_fail;
4273 temp2 = true;
4274 }
4275 {
4276 PyThreadState* __tstate = wxPyBeginAllowThreads();
4277 (arg1)->SetParameters((wxString const &)*arg2);
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 resultobj = SWIG_Py_Void();
4282 {
4283 if (temp2)
4284 delete arg2;
4285 }
4286 return resultobj;
4287 fail:
4288 {
4289 if (temp2)
4290 delete arg2;
4291 }
4292 return NULL;
4293 }
4294
4295
4296 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4297 PyObject *obj;
4298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4299 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4300 return SWIG_Py_Void();
4301 }
4302
4303 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4304 return SWIG_Python_InitShadowInstance(args);
4305 }
4306
4307 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxGridCellStringRenderer *result = 0 ;
4310
4311 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4326 PyObject *obj;
4327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4328 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4329 return SWIG_Py_Void();
4330 }
4331
4332 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4333 return SWIG_Python_InitShadowInstance(args);
4334 }
4335
4336 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 PyObject *resultobj = 0;
4338 wxGridCellNumberRenderer *result = 0 ;
4339
4340 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4355 PyObject *obj;
4356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4357 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4358 return SWIG_Py_Void();
4359 }
4360
4361 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4362 return SWIG_Python_InitShadowInstance(args);
4363 }
4364
4365 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj = 0;
4367 int arg1 = (int) -1 ;
4368 int arg2 = (int) -1 ;
4369 wxGridCellFloatRenderer *result = 0 ;
4370 int val1 ;
4371 int ecode1 = 0 ;
4372 int val2 ;
4373 int ecode2 = 0 ;
4374 PyObject * obj0 = 0 ;
4375 PyObject * obj1 = 0 ;
4376 char * kwnames[] = {
4377 (char *) "width",(char *) "precision", NULL
4378 };
4379
4380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4381 if (obj0) {
4382 ecode1 = SWIG_AsVal_int(obj0, &val1);
4383 if (!SWIG_IsOK(ecode1)) {
4384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4385 }
4386 arg1 = static_cast< int >(val1);
4387 }
4388 if (obj1) {
4389 ecode2 = SWIG_AsVal_int(obj1, &val2);
4390 if (!SWIG_IsOK(ecode2)) {
4391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4392 }
4393 arg2 = static_cast< int >(val2);
4394 }
4395 {
4396 PyThreadState* __tstate = wxPyBeginAllowThreads();
4397 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4398 wxPyEndAllowThreads(__tstate);
4399 if (PyErr_Occurred()) SWIG_fail;
4400 }
4401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4409 PyObject *resultobj = 0;
4410 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4411 int result;
4412 void *argp1 = 0 ;
4413 int res1 = 0 ;
4414 PyObject *swig_obj[1] ;
4415
4416 if (!args) SWIG_fail;
4417 swig_obj[0] = args;
4418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4419 if (!SWIG_IsOK(res1)) {
4420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4421 }
4422 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4423 {
4424 PyThreadState* __tstate = wxPyBeginAllowThreads();
4425 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4426 wxPyEndAllowThreads(__tstate);
4427 if (PyErr_Occurred()) SWIG_fail;
4428 }
4429 resultobj = SWIG_From_int(static_cast< int >(result));
4430 return resultobj;
4431 fail:
4432 return NULL;
4433 }
4434
4435
4436 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj = 0;
4438 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4439 int arg2 ;
4440 void *argp1 = 0 ;
4441 int res1 = 0 ;
4442 int val2 ;
4443 int ecode2 = 0 ;
4444 PyObject * obj0 = 0 ;
4445 PyObject * obj1 = 0 ;
4446 char * kwnames[] = {
4447 (char *) "self",(char *) "width", NULL
4448 };
4449
4450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4452 if (!SWIG_IsOK(res1)) {
4453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4454 }
4455 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4456 ecode2 = SWIG_AsVal_int(obj1, &val2);
4457 if (!SWIG_IsOK(ecode2)) {
4458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4459 }
4460 arg2 = static_cast< int >(val2);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 (arg1)->SetWidth(arg2);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *resultobj = 0;
4476 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4477 int result;
4478 void *argp1 = 0 ;
4479 int res1 = 0 ;
4480 PyObject *swig_obj[1] ;
4481
4482 if (!args) SWIG_fail;
4483 swig_obj[0] = args;
4484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4485 if (!SWIG_IsOK(res1)) {
4486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4487 }
4488 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 resultobj = SWIG_From_int(static_cast< int >(result));
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4505 int arg2 ;
4506 void *argp1 = 0 ;
4507 int res1 = 0 ;
4508 int val2 ;
4509 int ecode2 = 0 ;
4510 PyObject * obj0 = 0 ;
4511 PyObject * obj1 = 0 ;
4512 char * kwnames[] = {
4513 (char *) "self",(char *) "precision", NULL
4514 };
4515
4516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4518 if (!SWIG_IsOK(res1)) {
4519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4520 }
4521 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4522 ecode2 = SWIG_AsVal_int(obj1, &val2);
4523 if (!SWIG_IsOK(ecode2)) {
4524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4525 }
4526 arg2 = static_cast< int >(val2);
4527 {
4528 PyThreadState* __tstate = wxPyBeginAllowThreads();
4529 (arg1)->SetPrecision(arg2);
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 resultobj = SWIG_Py_Void();
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4541 PyObject *obj;
4542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4543 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4544 return SWIG_Py_Void();
4545 }
4546
4547 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4548 return SWIG_Python_InitShadowInstance(args);
4549 }
4550
4551 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4552 PyObject *resultobj = 0;
4553 wxGridCellBoolRenderer *result = 0 ;
4554
4555 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4556 {
4557 PyThreadState* __tstate = wxPyBeginAllowThreads();
4558 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4559 wxPyEndAllowThreads(__tstate);
4560 if (PyErr_Occurred()) SWIG_fail;
4561 }
4562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4563 return resultobj;
4564 fail:
4565 return NULL;
4566 }
4567
4568
4569 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 PyObject *obj;
4571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4572 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4573 return SWIG_Py_Void();
4574 }
4575
4576 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4577 return SWIG_Python_InitShadowInstance(args);
4578 }
4579
4580 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4581 PyObject *resultobj = 0;
4582 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4583 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4584 wxGridCellDateTimeRenderer *result = 0 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char * kwnames[] = {
4588 (char *) "outformat",(char *) "informat", NULL
4589 };
4590
4591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4592 if (obj0) {
4593 {
4594 wxString* sptr = wxString_in_helper(obj0);
4595 if (sptr == NULL) SWIG_fail;
4596 arg1 = *sptr;
4597 delete sptr;
4598 }
4599 }
4600 if (obj1) {
4601 {
4602 wxString* sptr = wxString_in_helper(obj1);
4603 if (sptr == NULL) SWIG_fail;
4604 arg2 = *sptr;
4605 delete sptr;
4606 }
4607 }
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4615 return resultobj;
4616 fail:
4617 return NULL;
4618 }
4619
4620
4621 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 PyObject *obj;
4623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4624 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4625 return SWIG_Py_Void();
4626 }
4627
4628 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4629 return SWIG_Python_InitShadowInstance(args);
4630 }
4631
4632 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj = 0;
4634 wxString const &arg1_defvalue = wxPyEmptyString ;
4635 wxString *arg1 = (wxString *) &arg1_defvalue ;
4636 wxGridCellEnumRenderer *result = 0 ;
4637 bool temp1 = false ;
4638 PyObject * obj0 = 0 ;
4639 char * kwnames[] = {
4640 (char *) "choices", NULL
4641 };
4642
4643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4644 if (obj0) {
4645 {
4646 arg1 = wxString_in_helper(obj0);
4647 if (arg1 == NULL) SWIG_fail;
4648 temp1 = true;
4649 }
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4654 wxPyEndAllowThreads(__tstate);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4658 {
4659 if (temp1)
4660 delete arg1;
4661 }
4662 return resultobj;
4663 fail:
4664 {
4665 if (temp1)
4666 delete arg1;
4667 }
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673 PyObject *obj;
4674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4675 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4676 return SWIG_Py_Void();
4677 }
4678
4679 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4680 return SWIG_Python_InitShadowInstance(args);
4681 }
4682
4683 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4684 PyObject *resultobj = 0;
4685 wxGridCellAutoWrapStringRenderer *result = 0 ;
4686
4687 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4688 {
4689 PyThreadState* __tstate = wxPyBeginAllowThreads();
4690 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4691 wxPyEndAllowThreads(__tstate);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4695 return resultobj;
4696 fail:
4697 return NULL;
4698 }
4699
4700
4701 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702 PyObject *obj;
4703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4704 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4705 return SWIG_Py_Void();
4706 }
4707
4708 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4709 return SWIG_Python_InitShadowInstance(args);
4710 }
4711
4712 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4715 bool result;
4716 void *argp1 = 0 ;
4717 int res1 = 0 ;
4718 PyObject *swig_obj[1] ;
4719
4720 if (!args) SWIG_fail;
4721 swig_obj[0] = args;
4722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4723 if (!SWIG_IsOK(res1)) {
4724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4725 }
4726 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (bool)(arg1)->IsCreated();
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 {
4734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4735 }
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4743 PyObject *resultobj = 0;
4744 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4745 wxControl *result = 0 ;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 PyObject *swig_obj[1] ;
4749
4750 if (!args) SWIG_fail;
4751 swig_obj[0] = args;
4752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4755 }
4756 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4757 {
4758 PyThreadState* __tstate = wxPyBeginAllowThreads();
4759 result = (wxControl *)(arg1)->GetControl();
4760 wxPyEndAllowThreads(__tstate);
4761 if (PyErr_Occurred()) SWIG_fail;
4762 }
4763 {
4764 resultobj = wxPyMake_wxObject(result, 0);
4765 }
4766 return resultobj;
4767 fail:
4768 return NULL;
4769 }
4770
4771
4772 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4773 PyObject *resultobj = 0;
4774 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4775 wxControl *arg2 = (wxControl *) 0 ;
4776 void *argp1 = 0 ;
4777 int res1 = 0 ;
4778 void *argp2 = 0 ;
4779 int res2 = 0 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 char * kwnames[] = {
4783 (char *) "self",(char *) "control", NULL
4784 };
4785
4786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4788 if (!SWIG_IsOK(res1)) {
4789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4790 }
4791 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4793 if (!SWIG_IsOK(res2)) {
4794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4795 }
4796 arg2 = reinterpret_cast< wxControl * >(argp2);
4797 {
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 (arg1)->SetControl(arg2);
4800 wxPyEndAllowThreads(__tstate);
4801 if (PyErr_Occurred()) SWIG_fail;
4802 }
4803 resultobj = SWIG_Py_Void();
4804 return resultobj;
4805 fail:
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4811 PyObject *resultobj = 0;
4812 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4813 wxGridCellAttr *result = 0 ;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 PyObject *swig_obj[1] ;
4817
4818 if (!args) SWIG_fail;
4819 swig_obj[0] = args;
4820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4821 if (!SWIG_IsOK(res1)) {
4822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4823 }
4824 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 {
4832 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4833 }
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4843 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 void *argp2 = 0 ;
4847 int res2 = 0 ;
4848 PyObject * obj0 = 0 ;
4849 PyObject * obj1 = 0 ;
4850 char * kwnames[] = {
4851 (char *) "self",(char *) "attr", NULL
4852 };
4853
4854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4858 }
4859 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4860 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4861 if (!SWIG_IsOK(res2)) {
4862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4863 }
4864 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4865 {
4866 PyThreadState* __tstate = wxPyBeginAllowThreads();
4867 (arg1)->SetCellAttr(arg2);
4868 wxPyEndAllowThreads(__tstate);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_Py_Void();
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj = 0;
4880 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4881 wxWindow *arg2 = (wxWindow *) 0 ;
4882 int arg3 ;
4883 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4884 void *argp1 = 0 ;
4885 int res1 = 0 ;
4886 void *argp2 = 0 ;
4887 int res2 = 0 ;
4888 int val3 ;
4889 int ecode3 = 0 ;
4890 void *argp4 = 0 ;
4891 int res4 = 0 ;
4892 PyObject * obj0 = 0 ;
4893 PyObject * obj1 = 0 ;
4894 PyObject * obj2 = 0 ;
4895 PyObject * obj3 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4904 }
4905 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4907 if (!SWIG_IsOK(res2)) {
4908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4909 }
4910 arg2 = reinterpret_cast< wxWindow * >(argp2);
4911 ecode3 = SWIG_AsVal_int(obj2, &val3);
4912 if (!SWIG_IsOK(ecode3)) {
4913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4914 }
4915 arg3 = static_cast< int >(val3);
4916 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4917 if (!SWIG_IsOK(res4)) {
4918 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4919 }
4920 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 (arg1)->Create(arg2,arg3,arg4);
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 resultobj = SWIG_Py_Void();
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj = 0;
4936 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4937 int arg2 ;
4938 int arg3 ;
4939 wxGrid *arg4 = (wxGrid *) 0 ;
4940 void *argp1 = 0 ;
4941 int res1 = 0 ;
4942 int val2 ;
4943 int ecode2 = 0 ;
4944 int val3 ;
4945 int ecode3 = 0 ;
4946 void *argp4 = 0 ;
4947 int res4 = 0 ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 PyObject * obj2 = 0 ;
4951 PyObject * obj3 = 0 ;
4952 char * kwnames[] = {
4953 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4954 };
4955
4956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4958 if (!SWIG_IsOK(res1)) {
4959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4960 }
4961 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4962 ecode2 = SWIG_AsVal_int(obj1, &val2);
4963 if (!SWIG_IsOK(ecode2)) {
4964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4965 }
4966 arg2 = static_cast< int >(val2);
4967 ecode3 = SWIG_AsVal_int(obj2, &val3);
4968 if (!SWIG_IsOK(ecode3)) {
4969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4970 }
4971 arg3 = static_cast< int >(val3);
4972 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4973 if (!SWIG_IsOK(res4)) {
4974 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4975 }
4976 arg4 = reinterpret_cast< wxGrid * >(argp4);
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 (arg1)->BeginEdit(arg2,arg3,arg4);
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_Py_Void();
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4991 PyObject *resultobj = 0;
4992 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4993 int arg2 ;
4994 int arg3 ;
4995 wxGrid *arg4 = (wxGrid *) 0 ;
4996 bool result;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 int val2 ;
5000 int ecode2 = 0 ;
5001 int val3 ;
5002 int ecode3 = 0 ;
5003 void *argp4 = 0 ;
5004 int res4 = 0 ;
5005 PyObject * obj0 = 0 ;
5006 PyObject * obj1 = 0 ;
5007 PyObject * obj2 = 0 ;
5008 PyObject * obj3 = 0 ;
5009 char * kwnames[] = {
5010 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5011 };
5012
5013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5015 if (!SWIG_IsOK(res1)) {
5016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5017 }
5018 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5019 ecode2 = SWIG_AsVal_int(obj1, &val2);
5020 if (!SWIG_IsOK(ecode2)) {
5021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5022 }
5023 arg2 = static_cast< int >(val2);
5024 ecode3 = SWIG_AsVal_int(obj2, &val3);
5025 if (!SWIG_IsOK(ecode3)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5027 }
5028 arg3 = static_cast< int >(val3);
5029 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5030 if (!SWIG_IsOK(res4)) {
5031 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5032 }
5033 arg4 = reinterpret_cast< wxGrid * >(argp4);
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 PyObject *swig_obj[1] ;
5055
5056 if (!args) SWIG_fail;
5057 swig_obj[0] = args;
5058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5059 if (!SWIG_IsOK(res1)) {
5060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5061 }
5062 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 (arg1)->Reset();
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_Py_Void();
5070 return resultobj;
5071 fail:
5072 return NULL;
5073 }
5074
5075
5076 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5077 PyObject *resultobj = 0;
5078 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5079 wxGridCellEditor *result = 0 ;
5080 void *argp1 = 0 ;
5081 int res1 = 0 ;
5082 PyObject *swig_obj[1] ;
5083
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5089 }
5090 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5109 wxRect *arg2 = 0 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 wxRect temp2 ;
5113 PyObject * obj0 = 0 ;
5114 PyObject * obj1 = 0 ;
5115 char * kwnames[] = {
5116 (char *) "self",(char *) "rect", NULL
5117 };
5118
5119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5121 if (!SWIG_IsOK(res1)) {
5122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5123 }
5124 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5125 {
5126 arg2 = &temp2;
5127 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5128 }
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 (arg1)->SetSize((wxRect const &)*arg2);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj = 0;
5144 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5145 bool arg2 ;
5146 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5147 void *argp1 = 0 ;
5148 int res1 = 0 ;
5149 bool val2 ;
5150 int ecode2 = 0 ;
5151 void *argp3 = 0 ;
5152 int res3 = 0 ;
5153 PyObject * obj0 = 0 ;
5154 PyObject * obj1 = 0 ;
5155 PyObject * obj2 = 0 ;
5156 char * kwnames[] = {
5157 (char *) "self",(char *) "show",(char *) "attr", NULL
5158 };
5159
5160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5162 if (!SWIG_IsOK(res1)) {
5163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5164 }
5165 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5167 if (!SWIG_IsOK(ecode2)) {
5168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5169 }
5170 arg2 = static_cast< bool >(val2);
5171 if (obj2) {
5172 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5173 if (!SWIG_IsOK(res3)) {
5174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5175 }
5176 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5177 }
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 (arg1)->Show(arg2,arg3);
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 resultobj = SWIG_Py_Void();
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5192 PyObject *resultobj = 0;
5193 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5194 wxRect *arg2 = 0 ;
5195 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5196 void *argp1 = 0 ;
5197 int res1 = 0 ;
5198 wxRect temp2 ;
5199 void *argp3 = 0 ;
5200 int res3 = 0 ;
5201 PyObject * obj0 = 0 ;
5202 PyObject * obj1 = 0 ;
5203 PyObject * obj2 = 0 ;
5204 char * kwnames[] = {
5205 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5206 };
5207
5208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5210 if (!SWIG_IsOK(res1)) {
5211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5212 }
5213 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5214 {
5215 arg2 = &temp2;
5216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5217 }
5218 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5219 if (!SWIG_IsOK(res3)) {
5220 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5221 }
5222 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 resultobj = SWIG_Py_Void();
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5239 wxKeyEvent *arg2 = 0 ;
5240 bool result;
5241 void *argp1 = 0 ;
5242 int res1 = 0 ;
5243 void *argp2 = 0 ;
5244 int res2 = 0 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char * kwnames[] = {
5248 (char *) "self",(char *) "event", NULL
5249 };
5250
5251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5253 if (!SWIG_IsOK(res1)) {
5254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5255 }
5256 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5258 if (!SWIG_IsOK(res2)) {
5259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5260 }
5261 if (!argp2) {
5262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5263 }
5264 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5273 }
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj = 0;
5282 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5283 wxKeyEvent *arg2 = 0 ;
5284 void *argp1 = 0 ;
5285 int res1 = 0 ;
5286 void *argp2 = 0 ;
5287 int res2 = 0 ;
5288 PyObject * obj0 = 0 ;
5289 PyObject * obj1 = 0 ;
5290 char * kwnames[] = {
5291 (char *) "self",(char *) "event", NULL
5292 };
5293
5294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5296 if (!SWIG_IsOK(res1)) {
5297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5298 }
5299 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5300 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5301 if (!SWIG_IsOK(res2)) {
5302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5303 }
5304 if (!argp2) {
5305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5306 }
5307 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 (arg1)->StartingKey(*arg2);
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_Py_Void();
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 PyObject *resultobj = 0;
5323 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5324 void *argp1 = 0 ;
5325 int res1 = 0 ;
5326 PyObject *swig_obj[1] ;
5327
5328 if (!args) SWIG_fail;
5329 swig_obj[0] = args;
5330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5331 if (!SWIG_IsOK(res1)) {
5332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5333 }
5334 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5335 {
5336 PyThreadState* __tstate = wxPyBeginAllowThreads();
5337 (arg1)->StartingClick();
5338 wxPyEndAllowThreads(__tstate);
5339 if (PyErr_Occurred()) SWIG_fail;
5340 }
5341 resultobj = SWIG_Py_Void();
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5349 PyObject *resultobj = 0;
5350 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5351 wxKeyEvent *arg2 = 0 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 void *argp2 = 0 ;
5355 int res2 = 0 ;
5356 PyObject * obj0 = 0 ;
5357 PyObject * obj1 = 0 ;
5358 char * kwnames[] = {
5359 (char *) "self",(char *) "event", NULL
5360 };
5361
5362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5364 if (!SWIG_IsOK(res1)) {
5365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5366 }
5367 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5369 if (!SWIG_IsOK(res2)) {
5370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5371 }
5372 if (!argp2) {
5373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5374 }
5375 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5376 {
5377 PyThreadState* __tstate = wxPyBeginAllowThreads();
5378 (arg1)->HandleReturn(*arg2);
5379 wxPyEndAllowThreads(__tstate);
5380 if (PyErr_Occurred()) SWIG_fail;
5381 }
5382 resultobj = SWIG_Py_Void();
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5390 PyObject *resultobj = 0;
5391 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5392 void *argp1 = 0 ;
5393 int res1 = 0 ;
5394 PyObject *swig_obj[1] ;
5395
5396 if (!args) SWIG_fail;
5397 swig_obj[0] = args;
5398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5399 if (!SWIG_IsOK(res1)) {
5400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5401 }
5402 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5403 {
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 (arg1)->Destroy();
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 resultobj = SWIG_Py_Void();
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *obj;
5418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5419 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5420 return SWIG_Py_Void();
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxPyGridCellEditor *result = 0 ;
5426
5427 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5435 return resultobj;
5436 fail:
5437 return NULL;
5438 }
5439
5440
5441 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5442 PyObject *resultobj = 0;
5443 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5444 PyObject *arg2 = (PyObject *) 0 ;
5445 PyObject *arg3 = (PyObject *) 0 ;
5446 void *argp1 = 0 ;
5447 int res1 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 PyObject * obj2 = 0 ;
5451 char * kwnames[] = {
5452 (char *) "self",(char *) "self",(char *) "_class", NULL
5453 };
5454
5455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5457 if (!SWIG_IsOK(res1)) {
5458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5459 }
5460 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5461 arg2 = obj1;
5462 arg3 = obj2;
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 (arg1)->_setCallbackInfo(arg2,arg3);
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 resultobj = SWIG_Py_Void();
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj = 0;
5478 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5479 wxString *arg2 = 0 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 bool temp2 = false ;
5483 PyObject * obj0 = 0 ;
5484 PyObject * obj1 = 0 ;
5485 char * kwnames[] = {
5486 (char *) "self",(char *) "params", NULL
5487 };
5488
5489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5491 if (!SWIG_IsOK(res1)) {
5492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5493 }
5494 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5495 {
5496 arg2 = wxString_in_helper(obj1);
5497 if (arg2 == NULL) SWIG_fail;
5498 temp2 = true;
5499 }
5500 {
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 (arg1)->SetParameters((wxString const &)*arg2);
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 resultobj = SWIG_Py_Void();
5507 {
5508 if (temp2)
5509 delete arg2;
5510 }
5511 return resultobj;
5512 fail:
5513 {
5514 if (temp2)
5515 delete arg2;
5516 }
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *obj;
5523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5524 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5525 return SWIG_Py_Void();
5526 }
5527
5528 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5529 return SWIG_Python_InitShadowInstance(args);
5530 }
5531
5532 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 PyObject *resultobj = 0;
5534 wxGridCellTextEditor *result = 0 ;
5535
5536 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5537 {
5538 PyThreadState* __tstate = wxPyBeginAllowThreads();
5539 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5551 PyObject *resultobj = 0;
5552 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5553 wxString result;
5554 void *argp1 = 0 ;
5555 int res1 = 0 ;
5556 PyObject *swig_obj[1] ;
5557
5558 if (!args) SWIG_fail;
5559 swig_obj[0] = args;
5560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5561 if (!SWIG_IsOK(res1)) {
5562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5563 }
5564 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 result = (arg1)->GetValue();
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 #if wxUSE_UNICODE
5573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5574 #else
5575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5576 #endif
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *obj;
5586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5587 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5588 return SWIG_Py_Void();
5589 }
5590
5591 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5592 return SWIG_Python_InitShadowInstance(args);
5593 }
5594
5595 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj = 0;
5597 int arg1 = (int) -1 ;
5598 int arg2 = (int) -1 ;
5599 wxGridCellNumberEditor *result = 0 ;
5600 int val1 ;
5601 int ecode1 = 0 ;
5602 int val2 ;
5603 int ecode2 = 0 ;
5604 PyObject * obj0 = 0 ;
5605 PyObject * obj1 = 0 ;
5606 char * kwnames[] = {
5607 (char *) "min",(char *) "max", NULL
5608 };
5609
5610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5611 if (obj0) {
5612 ecode1 = SWIG_AsVal_int(obj0, &val1);
5613 if (!SWIG_IsOK(ecode1)) {
5614 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5615 }
5616 arg1 = static_cast< int >(val1);
5617 }
5618 if (obj1) {
5619 ecode2 = SWIG_AsVal_int(obj1, &val2);
5620 if (!SWIG_IsOK(ecode2)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5622 }
5623 arg2 = static_cast< int >(val2);
5624 }
5625 {
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5639 PyObject *obj;
5640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5641 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5642 return SWIG_Py_Void();
5643 }
5644
5645 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5646 return SWIG_Python_InitShadowInstance(args);
5647 }
5648
5649 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj = 0;
5651 int arg1 = (int) -1 ;
5652 int arg2 = (int) -1 ;
5653 wxGridCellFloatEditor *result = 0 ;
5654 int val1 ;
5655 int ecode1 = 0 ;
5656 int val2 ;
5657 int ecode2 = 0 ;
5658 PyObject * obj0 = 0 ;
5659 PyObject * obj1 = 0 ;
5660 char * kwnames[] = {
5661 (char *) "width",(char *) "precision", NULL
5662 };
5663
5664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5665 if (obj0) {
5666 ecode1 = SWIG_AsVal_int(obj0, &val1);
5667 if (!SWIG_IsOK(ecode1)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5669 }
5670 arg1 = static_cast< int >(val1);
5671 }
5672 if (obj1) {
5673 ecode2 = SWIG_AsVal_int(obj1, &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 }
5679 {
5680 PyThreadState* __tstate = wxPyBeginAllowThreads();
5681 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5682 wxPyEndAllowThreads(__tstate);
5683 if (PyErr_Occurred()) SWIG_fail;
5684 }
5685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5686 return resultobj;
5687 fail:
5688 return NULL;
5689 }
5690
5691
5692 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5693 PyObject *obj;
5694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5695 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5696 return SWIG_Py_Void();
5697 }
5698
5699 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5700 return SWIG_Python_InitShadowInstance(args);
5701 }
5702
5703 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 PyObject *resultobj = 0;
5705 wxGridCellBoolEditor *result = 0 ;
5706
5707 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5708 {
5709 PyThreadState* __tstate = wxPyBeginAllowThreads();
5710 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5711 wxPyEndAllowThreads(__tstate);
5712 if (PyErr_Occurred()) SWIG_fail;
5713 }
5714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5722 PyObject *obj;
5723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5724 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5725 return SWIG_Py_Void();
5726 }
5727
5728 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 return SWIG_Python_InitShadowInstance(args);
5730 }
5731
5732 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj = 0;
5734 int arg1 = (int) 0 ;
5735 wxString *arg2 = (wxString *) NULL ;
5736 bool arg3 = (bool) false ;
5737 wxGridCellChoiceEditor *result = 0 ;
5738 bool val3 ;
5739 int ecode3 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 PyObject * obj1 = 0 ;
5742 char * kwnames[] = {
5743 (char *) "choices",(char *) "allowOthers", NULL
5744 };
5745
5746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5747 if (obj0) {
5748 {
5749 arg1 = PyList_Size(obj0);
5750 arg2 = wxString_LIST_helper(obj0);
5751 if (arg2 == NULL) SWIG_fail;
5752 }
5753 }
5754 if (obj1) {
5755 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5756 if (!SWIG_IsOK(ecode3)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5758 }
5759 arg3 = static_cast< bool >(val3);
5760 }
5761 {
5762 PyThreadState* __tstate = wxPyBeginAllowThreads();
5763 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5764 wxPyEndAllowThreads(__tstate);
5765 if (PyErr_Occurred()) SWIG_fail;
5766 }
5767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5768 {
5769 if (arg2) delete [] arg2;
5770 }
5771 return resultobj;
5772 fail:
5773 {
5774 if (arg2) delete [] arg2;
5775 }
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5781 PyObject *obj;
5782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5783 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5784 return SWIG_Py_Void();
5785 }
5786
5787 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5788 return SWIG_Python_InitShadowInstance(args);
5789 }
5790
5791 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj = 0;
5793 wxString const &arg1_defvalue = wxPyEmptyString ;
5794 wxString *arg1 = (wxString *) &arg1_defvalue ;
5795 wxGridCellEnumEditor *result = 0 ;
5796 bool temp1 = false ;
5797 PyObject * obj0 = 0 ;
5798 char * kwnames[] = {
5799 (char *) "choices", NULL
5800 };
5801
5802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5803 if (obj0) {
5804 {
5805 arg1 = wxString_in_helper(obj0);
5806 if (arg1 == NULL) SWIG_fail;
5807 temp1 = true;
5808 }
5809 }
5810 {
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5817 {
5818 if (temp1)
5819 delete arg1;
5820 }
5821 return resultobj;
5822 fail:
5823 {
5824 if (temp1)
5825 delete arg1;
5826 }
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5832 PyObject *obj;
5833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5834 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5835 return SWIG_Py_Void();
5836 }
5837
5838 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5839 return SWIG_Python_InitShadowInstance(args);
5840 }
5841
5842 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5843 PyObject *resultobj = 0;
5844 wxGridCellAutoWrapStringEditor *result = 0 ;
5845
5846 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5850 wxPyEndAllowThreads(__tstate);
5851 if (PyErr_Occurred()) SWIG_fail;
5852 }
5853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5854 return resultobj;
5855 fail:
5856 return NULL;
5857 }
5858
5859
5860 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5861 PyObject *obj;
5862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5863 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5864 return SWIG_Py_Void();
5865 }
5866
5867 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 return SWIG_Python_InitShadowInstance(args);
5869 }
5870
5871 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj = 0;
5873 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5874 PyObject *arg2 = (PyObject *) 0 ;
5875 void *argp1 = 0 ;
5876 int res1 = 0 ;
5877 PyObject * obj0 = 0 ;
5878 PyObject * obj1 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "self",(char *) "_self", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5885 if (!SWIG_IsOK(res1)) {
5886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5887 }
5888 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5889 arg2 = obj1;
5890 {
5891 PyThreadState* __tstate = wxPyBeginAllowThreads();
5892 wxGridCellAttr__setOORInfo(arg1,arg2);
5893 wxPyEndAllowThreads(__tstate);
5894 if (PyErr_Occurred()) SWIG_fail;
5895 }
5896 resultobj = SWIG_Py_Void();
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj = 0;
5905 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5906 wxGridCellAttr *result = 0 ;
5907 void *argp1 = 0 ;
5908 int res1 = 0 ;
5909 PyObject * obj0 = 0 ;
5910 char * kwnames[] = {
5911 (char *) "attrDefault", NULL
5912 };
5913
5914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5915 if (obj0) {
5916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5919 }
5920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5921 }
5922 {
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 {
5929 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5938 PyObject *resultobj = 0;
5939 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5940 void *argp1 = 0 ;
5941 int res1 = 0 ;
5942 PyObject *swig_obj[1] ;
5943
5944 if (!args) SWIG_fail;
5945 swig_obj[0] = args;
5946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5947 if (!SWIG_IsOK(res1)) {
5948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5949 }
5950 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 delete_wxGridCellAttr(arg1);
5954
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 resultobj = SWIG_Py_Void();
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5966 PyObject *resultobj = 0;
5967 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5968 wxGridCellAttr *result = 0 ;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 PyObject *swig_obj[1] ;
5972
5973 if (!args) SWIG_fail;
5974 swig_obj[0] = args;
5975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5978 }
5979 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 {
5987 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5988 }
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj = 0;
5997 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5998 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5999 void *argp1 = 0 ;
6000 int res1 = 0 ;
6001 void *argp2 = 0 ;
6002 int res2 = 0 ;
6003 PyObject * obj0 = 0 ;
6004 PyObject * obj1 = 0 ;
6005 char * kwnames[] = {
6006 (char *) "self",(char *) "mergefrom", NULL
6007 };
6008
6009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6011 if (!SWIG_IsOK(res1)) {
6012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6013 }
6014 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6015 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6016 if (!SWIG_IsOK(res2)) {
6017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6018 }
6019 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 (arg1)->MergeWith(arg2);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_Py_Void();
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6034 PyObject *resultobj = 0;
6035 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6036 void *argp1 = 0 ;
6037 int res1 = 0 ;
6038 PyObject *swig_obj[1] ;
6039
6040 if (!args) SWIG_fail;
6041 swig_obj[0] = args;
6042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6043 if (!SWIG_IsOK(res1)) {
6044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6045 }
6046 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 (arg1)->IncRef();
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 resultobj = SWIG_Py_Void();
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *resultobj = 0;
6062 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6063 void *argp1 = 0 ;
6064 int res1 = 0 ;
6065 PyObject *swig_obj[1] ;
6066
6067 if (!args) SWIG_fail;
6068 swig_obj[0] = args;
6069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6070 if (!SWIG_IsOK(res1)) {
6071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6072 }
6073 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6074 {
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 (arg1)->DecRef();
6077 wxPyEndAllowThreads(__tstate);
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_Py_Void();
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6090 wxColour *arg2 = 0 ;
6091 void *argp1 = 0 ;
6092 int res1 = 0 ;
6093 wxColour temp2 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char * kwnames[] = {
6097 (char *) "self",(char *) "colText", NULL
6098 };
6099
6100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6104 }
6105 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6106 {
6107 arg2 = &temp2;
6108 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6109 }
6110 {
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 (arg1)->SetTextColour((wxColour const &)*arg2);
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 resultobj = SWIG_Py_Void();
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj = 0;
6125 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6126 wxColour *arg2 = 0 ;
6127 void *argp1 = 0 ;
6128 int res1 = 0 ;
6129 wxColour temp2 ;
6130 PyObject * obj0 = 0 ;
6131 PyObject * obj1 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "self",(char *) "colBack", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6138 if (!SWIG_IsOK(res1)) {
6139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6140 }
6141 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6142 {
6143 arg2 = &temp2;
6144 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6145 }
6146 {
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6149 wxPyEndAllowThreads(__tstate);
6150 if (PyErr_Occurred()) SWIG_fail;
6151 }
6152 resultobj = SWIG_Py_Void();
6153 return resultobj;
6154 fail:
6155 return NULL;
6156 }
6157
6158
6159 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj = 0;
6161 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6162 wxFont *arg2 = 0 ;
6163 void *argp1 = 0 ;
6164 int res1 = 0 ;
6165 void *argp2 = 0 ;
6166 int res2 = 0 ;
6167 PyObject * obj0 = 0 ;
6168 PyObject * obj1 = 0 ;
6169 char * kwnames[] = {
6170 (char *) "self",(char *) "font", NULL
6171 };
6172
6173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6175 if (!SWIG_IsOK(res1)) {
6176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6177 }
6178 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6179 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6180 if (!SWIG_IsOK(res2)) {
6181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6182 }
6183 if (!argp2) {
6184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6185 }
6186 arg2 = reinterpret_cast< wxFont * >(argp2);
6187 {
6188 PyThreadState* __tstate = wxPyBeginAllowThreads();
6189 (arg1)->SetFont((wxFont const &)*arg2);
6190 wxPyEndAllowThreads(__tstate);
6191 if (PyErr_Occurred()) SWIG_fail;
6192 }
6193 resultobj = SWIG_Py_Void();
6194 return resultobj;
6195 fail:
6196 return NULL;
6197 }
6198
6199
6200 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6201 PyObject *resultobj = 0;
6202 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6203 int arg2 ;
6204 int arg3 ;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 int val2 ;
6208 int ecode2 = 0 ;
6209 int val3 ;
6210 int ecode3 = 0 ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 PyObject * obj2 = 0 ;
6214 char * kwnames[] = {
6215 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6216 };
6217
6218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6220 if (!SWIG_IsOK(res1)) {
6221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6222 }
6223 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6224 ecode2 = SWIG_AsVal_int(obj1, &val2);
6225 if (!SWIG_IsOK(ecode2)) {
6226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6227 }
6228 arg2 = static_cast< int >(val2);
6229 ecode3 = SWIG_AsVal_int(obj2, &val3);
6230 if (!SWIG_IsOK(ecode3)) {
6231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6232 }
6233 arg3 = static_cast< int >(val3);
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 (arg1)->SetAlignment(arg2,arg3);
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 resultobj = SWIG_Py_Void();
6241 return resultobj;
6242 fail:
6243 return NULL;
6244 }
6245
6246
6247 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6248 PyObject *resultobj = 0;
6249 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6250 int arg2 ;
6251 int arg3 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 int val2 ;
6255 int ecode2 = 0 ;
6256 int val3 ;
6257 int ecode3 = 0 ;
6258 PyObject * obj0 = 0 ;
6259 PyObject * obj1 = 0 ;
6260 PyObject * obj2 = 0 ;
6261 char * kwnames[] = {
6262 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6263 };
6264
6265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6267 if (!SWIG_IsOK(res1)) {
6268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6269 }
6270 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6271 ecode2 = SWIG_AsVal_int(obj1, &val2);
6272 if (!SWIG_IsOK(ecode2)) {
6273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6274 }
6275 arg2 = static_cast< int >(val2);
6276 ecode3 = SWIG_AsVal_int(obj2, &val3);
6277 if (!SWIG_IsOK(ecode3)) {
6278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6279 }
6280 arg3 = static_cast< int >(val3);
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 (arg1)->SetSize(arg2,arg3);
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 resultobj = SWIG_Py_Void();
6288 return resultobj;
6289 fail:
6290 return NULL;
6291 }
6292
6293
6294 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6295 PyObject *resultobj = 0;
6296 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6297 bool arg2 = (bool) true ;
6298 void *argp1 = 0 ;
6299 int res1 = 0 ;
6300 bool val2 ;
6301 int ecode2 = 0 ;
6302 PyObject * obj0 = 0 ;
6303 PyObject * obj1 = 0 ;
6304 char * kwnames[] = {
6305 (char *) "self",(char *) "allow", NULL
6306 };
6307
6308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6310 if (!SWIG_IsOK(res1)) {
6311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6312 }
6313 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6314 if (obj1) {
6315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6316 if (!SWIG_IsOK(ecode2)) {
6317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6318 }
6319 arg2 = static_cast< bool >(val2);
6320 }
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 (arg1)->SetOverflow(arg2);
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 resultobj = SWIG_Py_Void();
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6335 PyObject *resultobj = 0;
6336 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6337 bool arg2 = (bool) true ;
6338 void *argp1 = 0 ;
6339 int res1 = 0 ;
6340 bool val2 ;
6341 int ecode2 = 0 ;
6342 PyObject * obj0 = 0 ;
6343 PyObject * obj1 = 0 ;
6344 char * kwnames[] = {
6345 (char *) "self",(char *) "isReadOnly", NULL
6346 };
6347
6348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6350 if (!SWIG_IsOK(res1)) {
6351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6352 }
6353 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6354 if (obj1) {
6355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6356 if (!SWIG_IsOK(ecode2)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6358 }
6359 arg2 = static_cast< bool >(val2);
6360 }
6361 {
6362 PyThreadState* __tstate = wxPyBeginAllowThreads();
6363 (arg1)->SetReadOnly(arg2);
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_Py_Void();
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6375 PyObject *resultobj = 0;
6376 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6377 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 void *argp2 = 0 ;
6381 int res2 = 0 ;
6382 PyObject * obj0 = 0 ;
6383 PyObject * obj1 = 0 ;
6384 char * kwnames[] = {
6385 (char *) "self",(char *) "renderer", NULL
6386 };
6387
6388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6390 if (!SWIG_IsOK(res1)) {
6391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6392 }
6393 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6395 if (!SWIG_IsOK(res2)) {
6396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6397 }
6398 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6399 {
6400 PyThreadState* __tstate = wxPyBeginAllowThreads();
6401 (arg1)->SetRenderer(arg2);
6402 wxPyEndAllowThreads(__tstate);
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 resultobj = SWIG_Py_Void();
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6413 PyObject *resultobj = 0;
6414 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6415 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6416 void *argp1 = 0 ;
6417 int res1 = 0 ;
6418 void *argp2 = 0 ;
6419 int res2 = 0 ;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 char * kwnames[] = {
6423 (char *) "self",(char *) "editor", NULL
6424 };
6425
6426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6428 if (!SWIG_IsOK(res1)) {
6429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6430 }
6431 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6432 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6433 if (!SWIG_IsOK(res2)) {
6434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6435 }
6436 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6437 {
6438 PyThreadState* __tstate = wxPyBeginAllowThreads();
6439 (arg1)->SetEditor(arg2);
6440 wxPyEndAllowThreads(__tstate);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_Py_Void();
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj = 0;
6452 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6453 wxGridCellAttr::wxAttrKind arg2 ;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 int val2 ;
6457 int ecode2 = 0 ;
6458 PyObject * obj0 = 0 ;
6459 PyObject * obj1 = 0 ;
6460 char * kwnames[] = {
6461 (char *) "self",(char *) "kind", NULL
6462 };
6463
6464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6468 }
6469 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6470 ecode2 = SWIG_AsVal_int(obj1, &val2);
6471 if (!SWIG_IsOK(ecode2)) {
6472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6473 }
6474 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 (arg1)->SetKind(arg2);
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_Py_Void();
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6489 PyObject *resultobj = 0;
6490 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6491 bool result;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 PyObject *swig_obj[1] ;
6495
6496 if (!args) SWIG_fail;
6497 swig_obj[0] = args;
6498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6499 if (!SWIG_IsOK(res1)) {
6500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6501 }
6502 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6506 wxPyEndAllowThreads(__tstate);
6507 if (PyErr_Occurred()) SWIG_fail;
6508 }
6509 {
6510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6511 }
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6519 PyObject *resultobj = 0;
6520 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6521 bool result;
6522 void *argp1 = 0 ;
6523 int res1 = 0 ;
6524 PyObject *swig_obj[1] ;
6525
6526 if (!args) SWIG_fail;
6527 swig_obj[0] = args;
6528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6529 if (!SWIG_IsOK(res1)) {
6530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6531 }
6532 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6533 {
6534 PyThreadState* __tstate = wxPyBeginAllowThreads();
6535 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6536 wxPyEndAllowThreads(__tstate);
6537 if (PyErr_Occurred()) SWIG_fail;
6538 }
6539 {
6540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6541 }
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6549 PyObject *resultobj = 0;
6550 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6551 bool result;
6552 void *argp1 = 0 ;
6553 int res1 = 0 ;
6554 PyObject *swig_obj[1] ;
6555
6556 if (!args) SWIG_fail;
6557 swig_obj[0] = args;
6558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6559 if (!SWIG_IsOK(res1)) {
6560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6561 }
6562 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 {
6570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6571 }
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6579 PyObject *resultobj = 0;
6580 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6581 bool result;
6582 void *argp1 = 0 ;
6583 int res1 = 0 ;
6584 PyObject *swig_obj[1] ;
6585
6586 if (!args) SWIG_fail;
6587 swig_obj[0] = args;
6588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6591 }
6592 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 {
6600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6601 }
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6609 PyObject *resultobj = 0;
6610 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6611 bool result;
6612 void *argp1 = 0 ;
6613 int res1 = 0 ;
6614 PyObject *swig_obj[1] ;
6615
6616 if (!args) SWIG_fail;
6617 swig_obj[0] = args;
6618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6619 if (!SWIG_IsOK(res1)) {
6620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6621 }
6622 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 {
6630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6631 }
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6641 bool result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 {
6660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6661 }
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 PyObject *resultobj = 0;
6670 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6671 bool result;
6672 void *argp1 = 0 ;
6673 int res1 = 0 ;
6674 PyObject *swig_obj[1] ;
6675
6676 if (!args) SWIG_fail;
6677 swig_obj[0] = args;
6678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6679 if (!SWIG_IsOK(res1)) {
6680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6681 }
6682 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 {
6690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6691 }
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6699 PyObject *resultobj = 0;
6700 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6701 bool result;
6702 void *argp1 = 0 ;
6703 int res1 = 0 ;
6704 PyObject *swig_obj[1] ;
6705
6706 if (!args) SWIG_fail;
6707 swig_obj[0] = args;
6708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6709 if (!SWIG_IsOK(res1)) {
6710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6711 }
6712 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 {
6720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6721 }
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6729 PyObject *resultobj = 0;
6730 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6731 wxColour result;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 PyObject *swig_obj[1] ;
6735
6736 if (!args) SWIG_fail;
6737 swig_obj[0] = args;
6738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6739 if (!SWIG_IsOK(res1)) {
6740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6741 }
6742 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6759 wxColour result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6787 wxFont result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = ((wxGridCellAttr const *)arg1)->GetFont();
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6815 int *arg2 = (int *) 0 ;
6816 int *arg3 = (int *) 0 ;
6817 void *argp1 = 0 ;
6818 int res1 = 0 ;
6819 int temp2 ;
6820 int res2 = SWIG_TMPOBJ ;
6821 int temp3 ;
6822 int res3 = SWIG_TMPOBJ ;
6823 PyObject *swig_obj[1] ;
6824
6825 arg2 = &temp2;
6826 arg3 = &temp3;
6827 if (!args) SWIG_fail;
6828 swig_obj[0] = args;
6829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6830 if (!SWIG_IsOK(res1)) {
6831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6832 }
6833 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 if (SWIG_IsTmpObj(res2)) {
6842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6843 } else {
6844 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6846 }
6847 if (SWIG_IsTmpObj(res3)) {
6848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6849 } else {
6850 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6852 }
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6862 int *arg2 = (int *) 0 ;
6863 int *arg3 = (int *) 0 ;
6864 void *argp1 = 0 ;
6865 int res1 = 0 ;
6866 int temp2 ;
6867 int res2 = SWIG_TMPOBJ ;
6868 int temp3 ;
6869 int res3 = SWIG_TMPOBJ ;
6870 PyObject *swig_obj[1] ;
6871
6872 arg2 = &temp2;
6873 arg3 = &temp3;
6874 if (!args) SWIG_fail;
6875 swig_obj[0] = args;
6876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6877 if (!SWIG_IsOK(res1)) {
6878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6879 }
6880 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6881 {
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_Py_Void();
6888 if (SWIG_IsTmpObj(res2)) {
6889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6890 } else {
6891 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6893 }
6894 if (SWIG_IsTmpObj(res3)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6899 }
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6907 PyObject *resultobj = 0;
6908 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6909 bool result;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 PyObject *swig_obj[1] ;
6913
6914 if (!args) SWIG_fail;
6915 swig_obj[0] = args;
6916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6917 if (!SWIG_IsOK(res1)) {
6918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6919 }
6920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 {
6928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6929 }
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj = 0;
6938 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6939 wxGrid *arg2 = (wxGrid *) 0 ;
6940 int arg3 ;
6941 int arg4 ;
6942 wxGridCellRenderer *result = 0 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 void *argp2 = 0 ;
6946 int res2 = 0 ;
6947 int val3 ;
6948 int ecode3 = 0 ;
6949 int val4 ;
6950 int ecode4 = 0 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 PyObject * obj2 = 0 ;
6954 PyObject * obj3 = 0 ;
6955 char * kwnames[] = {
6956 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6957 };
6958
6959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6961 if (!SWIG_IsOK(res1)) {
6962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6963 }
6964 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6965 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6966 if (!SWIG_IsOK(res2)) {
6967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6968 }
6969 arg2 = reinterpret_cast< wxGrid * >(argp2);
6970 ecode3 = SWIG_AsVal_int(obj2, &val3);
6971 if (!SWIG_IsOK(ecode3)) {
6972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6973 }
6974 arg3 = static_cast< int >(val3);
6975 ecode4 = SWIG_AsVal_int(obj3, &val4);
6976 if (!SWIG_IsOK(ecode4)) {
6977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6978 }
6979 arg4 = static_cast< int >(val4);
6980 {
6981 PyThreadState* __tstate = wxPyBeginAllowThreads();
6982 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 {
6987 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6988 }
6989 return resultobj;
6990 fail:
6991 return NULL;
6992 }
6993
6994
6995 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj = 0;
6997 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6998 wxGrid *arg2 = (wxGrid *) 0 ;
6999 int arg3 ;
7000 int arg4 ;
7001 wxGridCellEditor *result = 0 ;
7002 void *argp1 = 0 ;
7003 int res1 = 0 ;
7004 void *argp2 = 0 ;
7005 int res2 = 0 ;
7006 int val3 ;
7007 int ecode3 = 0 ;
7008 int val4 ;
7009 int ecode4 = 0 ;
7010 PyObject * obj0 = 0 ;
7011 PyObject * obj1 = 0 ;
7012 PyObject * obj2 = 0 ;
7013 PyObject * obj3 = 0 ;
7014 char * kwnames[] = {
7015 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7016 };
7017
7018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7022 }
7023 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7025 if (!SWIG_IsOK(res2)) {
7026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7027 }
7028 arg2 = reinterpret_cast< wxGrid * >(argp2);
7029 ecode3 = SWIG_AsVal_int(obj2, &val3);
7030 if (!SWIG_IsOK(ecode3)) {
7031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7032 }
7033 arg3 = static_cast< int >(val3);
7034 ecode4 = SWIG_AsVal_int(obj3, &val4);
7035 if (!SWIG_IsOK(ecode4)) {
7036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7037 }
7038 arg4 = static_cast< int >(val4);
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 {
7046 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7047 }
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7055 PyObject *resultobj = 0;
7056 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7057 bool result;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 PyObject *swig_obj[1] ;
7061
7062 if (!args) SWIG_fail;
7063 swig_obj[0] = args;
7064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7065 if (!SWIG_IsOK(res1)) {
7066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7067 }
7068 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7069 {
7070 PyThreadState* __tstate = wxPyBeginAllowThreads();
7071 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7072 wxPyEndAllowThreads(__tstate);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 {
7076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7077 }
7078 return resultobj;
7079 fail:
7080 return NULL;
7081 }
7082
7083
7084 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7085 PyObject *resultobj = 0;
7086 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7087 wxGridCellAttr::wxAttrKind result;
7088 void *argp1 = 0 ;
7089 int res1 = 0 ;
7090 PyObject *swig_obj[1] ;
7091
7092 if (!args) SWIG_fail;
7093 swig_obj[0] = args;
7094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7095 if (!SWIG_IsOK(res1)) {
7096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7097 }
7098 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7099 {
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_From_int(static_cast< int >(result));
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj = 0;
7114 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7115 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 void *argp2 = 0 ;
7119 int res2 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "self",(char *) "defAttr", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7128 if (!SWIG_IsOK(res1)) {
7129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7130 }
7131 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7133 if (!SWIG_IsOK(res2)) {
7134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7135 }
7136 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 (arg1)->SetDefAttr(arg2);
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 resultobj = SWIG_Py_Void();
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7151 PyObject *obj;
7152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7153 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7154 return SWIG_Py_Void();
7155 }
7156
7157 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158 return SWIG_Python_InitShadowInstance(args);
7159 }
7160
7161 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7162 PyObject *resultobj = 0;
7163 wxGridCellAttrProvider *result = 0 ;
7164
7165 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 {
7173 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7174 }
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = 0;
7183 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7184 PyObject *arg2 = (PyObject *) 0 ;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 PyObject * obj0 = 0 ;
7188 PyObject * obj1 = 0 ;
7189 char * kwnames[] = {
7190 (char *) "self",(char *) "_self", NULL
7191 };
7192
7193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) 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__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7197 }
7198 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7199 arg2 = obj1;
7200 {
7201 PyThreadState* __tstate = wxPyBeginAllowThreads();
7202 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 resultobj = SWIG_Py_Void();
7207 return resultobj;
7208 fail:
7209 return NULL;
7210 }
7211
7212
7213 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7214 PyObject *resultobj = 0;
7215 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7216 int arg2 ;
7217 int arg3 ;
7218 wxGridCellAttr::wxAttrKind arg4 ;
7219 wxGridCellAttr *result = 0 ;
7220 void *argp1 = 0 ;
7221 int res1 = 0 ;
7222 int val2 ;
7223 int ecode2 = 0 ;
7224 int val3 ;
7225 int ecode3 = 0 ;
7226 int val4 ;
7227 int ecode4 = 0 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 PyObject * obj2 = 0 ;
7231 PyObject * obj3 = 0 ;
7232 char * kwnames[] = {
7233 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7234 };
7235
7236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7238 if (!SWIG_IsOK(res1)) {
7239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7240 }
7241 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7242 ecode2 = SWIG_AsVal_int(obj1, &val2);
7243 if (!SWIG_IsOK(ecode2)) {
7244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7245 }
7246 arg2 = static_cast< int >(val2);
7247 ecode3 = SWIG_AsVal_int(obj2, &val3);
7248 if (!SWIG_IsOK(ecode3)) {
7249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7250 }
7251 arg3 = static_cast< int >(val3);
7252 ecode4 = SWIG_AsVal_int(obj3, &val4);
7253 if (!SWIG_IsOK(ecode4)) {
7254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7255 }
7256 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 {
7264 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7265 }
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7275 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7276 int arg3 ;
7277 int arg4 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 void *argp2 = 0 ;
7281 int res2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 int val4 ;
7285 int ecode4 = 0 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 PyObject * obj2 = 0 ;
7289 PyObject * obj3 = 0 ;
7290 char * kwnames[] = {
7291 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7292 };
7293
7294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7296 if (!SWIG_IsOK(res1)) {
7297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7298 }
7299 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7301 if (!SWIG_IsOK(res2)) {
7302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7303 }
7304 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7305 ecode3 = SWIG_AsVal_int(obj2, &val3);
7306 if (!SWIG_IsOK(ecode3)) {
7307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7308 }
7309 arg3 = static_cast< int >(val3);
7310 ecode4 = SWIG_AsVal_int(obj3, &val4);
7311 if (!SWIG_IsOK(ecode4)) {
7312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7313 }
7314 arg4 = static_cast< int >(val4);
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 (arg1)->SetAttr(arg2,arg3,arg4);
7318 wxPyEndAllowThreads(__tstate);
7319 if (PyErr_Occurred()) SWIG_fail;
7320 }
7321 resultobj = SWIG_Py_Void();
7322 return resultobj;
7323 fail:
7324 return NULL;
7325 }
7326
7327
7328 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7329 PyObject *resultobj = 0;
7330 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7331 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7332 int arg3 ;
7333 void *argp1 = 0 ;
7334 int res1 = 0 ;
7335 void *argp2 = 0 ;
7336 int res2 = 0 ;
7337 int val3 ;
7338 int ecode3 = 0 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 PyObject * obj2 = 0 ;
7342 char * kwnames[] = {
7343 (char *) "self",(char *) "attr",(char *) "row", NULL
7344 };
7345
7346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7350 }
7351 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7353 if (!SWIG_IsOK(res2)) {
7354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7355 }
7356 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7357 ecode3 = SWIG_AsVal_int(obj2, &val3);
7358 if (!SWIG_IsOK(ecode3)) {
7359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7360 }
7361 arg3 = static_cast< int >(val3);
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 (arg1)->SetRowAttr(arg2,arg3);
7365 wxPyEndAllowThreads(__tstate);
7366 if (PyErr_Occurred()) SWIG_fail;
7367 }
7368 resultobj = SWIG_Py_Void();
7369 return resultobj;
7370 fail:
7371 return NULL;
7372 }
7373
7374
7375 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7376 PyObject *resultobj = 0;
7377 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7378 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7379 int arg3 ;
7380 void *argp1 = 0 ;
7381 int res1 = 0 ;
7382 void *argp2 = 0 ;
7383 int res2 = 0 ;
7384 int val3 ;
7385 int ecode3 = 0 ;
7386 PyObject * obj0 = 0 ;
7387 PyObject * obj1 = 0 ;
7388 PyObject * obj2 = 0 ;
7389 char * kwnames[] = {
7390 (char *) "self",(char *) "attr",(char *) "col", NULL
7391 };
7392
7393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7395 if (!SWIG_IsOK(res1)) {
7396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7397 }
7398 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7400 if (!SWIG_IsOK(res2)) {
7401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7402 }
7403 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7404 ecode3 = SWIG_AsVal_int(obj2, &val3);
7405 if (!SWIG_IsOK(ecode3)) {
7406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7407 }
7408 arg3 = static_cast< int >(val3);
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 (arg1)->SetColAttr(arg2,arg3);
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 resultobj = SWIG_Py_Void();
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj = 0;
7424 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7425 size_t arg2 ;
7426 int arg3 ;
7427 void *argp1 = 0 ;
7428 int res1 = 0 ;
7429 size_t val2 ;
7430 int ecode2 = 0 ;
7431 int val3 ;
7432 int ecode3 = 0 ;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 PyObject * obj2 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7444 }
7445 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7446 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7447 if (!SWIG_IsOK(ecode2)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7449 }
7450 arg2 = static_cast< size_t >(val2);
7451 ecode3 = SWIG_AsVal_int(obj2, &val3);
7452 if (!SWIG_IsOK(ecode3)) {
7453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7454 }
7455 arg3 = static_cast< int >(val3);
7456 {
7457 PyThreadState* __tstate = wxPyBeginAllowThreads();
7458 (arg1)->UpdateAttrRows(arg2,arg3);
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 resultobj = SWIG_Py_Void();
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj = 0;
7471 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7472 size_t arg2 ;
7473 int arg3 ;
7474 void *argp1 = 0 ;
7475 int res1 = 0 ;
7476 size_t val2 ;
7477 int ecode2 = 0 ;
7478 int val3 ;
7479 int ecode3 = 0 ;
7480 PyObject * obj0 = 0 ;
7481 PyObject * obj1 = 0 ;
7482 PyObject * obj2 = 0 ;
7483 char * kwnames[] = {
7484 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7485 };
7486
7487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7489 if (!SWIG_IsOK(res1)) {
7490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7491 }
7492 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7493 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7494 if (!SWIG_IsOK(ecode2)) {
7495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7496 }
7497 arg2 = static_cast< size_t >(val2);
7498 ecode3 = SWIG_AsVal_int(obj2, &val3);
7499 if (!SWIG_IsOK(ecode3)) {
7500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7501 }
7502 arg3 = static_cast< int >(val3);
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 (arg1)->UpdateAttrCols(arg2,arg3);
7506 wxPyEndAllowThreads(__tstate);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 resultobj = SWIG_Py_Void();
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *obj;
7518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7519 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7520 return SWIG_Py_Void();
7521 }
7522
7523 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524 return SWIG_Python_InitShadowInstance(args);
7525 }
7526
7527 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7528 PyObject *resultobj = 0;
7529 wxPyGridCellAttrProvider *result = 0 ;
7530
7531 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj = 0;
7547 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7548 PyObject *arg2 = (PyObject *) 0 ;
7549 PyObject *arg3 = (PyObject *) 0 ;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 PyObject * obj2 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "self",(char *) "_class", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7563 }
7564 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7565 arg2 = obj1;
7566 arg3 = obj2;
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 (arg1)->_setCallbackInfo(arg2,arg3);
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 resultobj = SWIG_Py_Void();
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7581 PyObject *resultobj = 0;
7582 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7583 int arg2 ;
7584 int arg3 ;
7585 wxGridCellAttr::wxAttrKind arg4 ;
7586 wxGridCellAttr *result = 0 ;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 int val2 ;
7590 int ecode2 = 0 ;
7591 int val3 ;
7592 int ecode3 = 0 ;
7593 int val4 ;
7594 int ecode4 = 0 ;
7595 PyObject * obj0 = 0 ;
7596 PyObject * obj1 = 0 ;
7597 PyObject * obj2 = 0 ;
7598 PyObject * obj3 = 0 ;
7599 char * kwnames[] = {
7600 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7601 };
7602
7603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7607 }
7608 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7609 ecode2 = SWIG_AsVal_int(obj1, &val2);
7610 if (!SWIG_IsOK(ecode2)) {
7611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7612 }
7613 arg2 = static_cast< int >(val2);
7614 ecode3 = SWIG_AsVal_int(obj2, &val3);
7615 if (!SWIG_IsOK(ecode3)) {
7616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7617 }
7618 arg3 = static_cast< int >(val3);
7619 ecode4 = SWIG_AsVal_int(obj3, &val4);
7620 if (!SWIG_IsOK(ecode4)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7622 }
7623 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7627 wxPyEndAllowThreads(__tstate);
7628 if (PyErr_Occurred()) SWIG_fail;
7629 }
7630 {
7631 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7632 }
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj = 0;
7641 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7642 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7643 int arg3 ;
7644 int arg4 ;
7645 void *argp1 = 0 ;
7646 int res1 = 0 ;
7647 void *argp2 = 0 ;
7648 int res2 = 0 ;
7649 int val3 ;
7650 int ecode3 = 0 ;
7651 int val4 ;
7652 int ecode4 = 0 ;
7653 PyObject * obj0 = 0 ;
7654 PyObject * obj1 = 0 ;
7655 PyObject * obj2 = 0 ;
7656 PyObject * obj3 = 0 ;
7657 char * kwnames[] = {
7658 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7659 };
7660
7661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7665 }
7666 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7668 if (!SWIG_IsOK(res2)) {
7669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7670 }
7671 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7672 ecode3 = SWIG_AsVal_int(obj2, &val3);
7673 if (!SWIG_IsOK(ecode3)) {
7674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7675 }
7676 arg3 = static_cast< int >(val3);
7677 ecode4 = SWIG_AsVal_int(obj3, &val4);
7678 if (!SWIG_IsOK(ecode4)) {
7679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7680 }
7681 arg4 = static_cast< int >(val4);
7682 {
7683 PyThreadState* __tstate = wxPyBeginAllowThreads();
7684 (arg1)->SetAttr(arg2,arg3,arg4);
7685 wxPyEndAllowThreads(__tstate);
7686 if (PyErr_Occurred()) SWIG_fail;
7687 }
7688 resultobj = SWIG_Py_Void();
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7698 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7699 int arg3 ;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 void *argp2 = 0 ;
7703 int res2 = 0 ;
7704 int val3 ;
7705 int ecode3 = 0 ;
7706 PyObject * obj0 = 0 ;
7707 PyObject * obj1 = 0 ;
7708 PyObject * obj2 = 0 ;
7709 char * kwnames[] = {
7710 (char *) "self",(char *) "attr",(char *) "row", NULL
7711 };
7712
7713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7717 }
7718 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7720 if (!SWIG_IsOK(res2)) {
7721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7722 }
7723 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7724 ecode3 = SWIG_AsVal_int(obj2, &val3);
7725 if (!SWIG_IsOK(ecode3)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7727 }
7728 arg3 = static_cast< int >(val3);
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 (arg1)->SetRowAttr(arg2,arg3);
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7745 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7746 int arg3 ;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 void *argp2 = 0 ;
7750 int res2 = 0 ;
7751 int val3 ;
7752 int ecode3 = 0 ;
7753 PyObject * obj0 = 0 ;
7754 PyObject * obj1 = 0 ;
7755 PyObject * obj2 = 0 ;
7756 char * kwnames[] = {
7757 (char *) "self",(char *) "attr",(char *) "col", NULL
7758 };
7759
7760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7764 }
7765 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7767 if (!SWIG_IsOK(res2)) {
7768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7769 }
7770 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7771 ecode3 = SWIG_AsVal_int(obj2, &val3);
7772 if (!SWIG_IsOK(ecode3)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7774 }
7775 arg3 = static_cast< int >(val3);
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 (arg1)->SetColAttr(arg2,arg3);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_Py_Void();
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7790 PyObject *obj;
7791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7792 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7793 return SWIG_Py_Void();
7794 }
7795
7796 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 return SWIG_Python_InitShadowInstance(args);
7798 }
7799
7800 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7801 PyObject *resultobj = 0;
7802 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 PyObject *swig_obj[1] ;
7806
7807 if (!args) SWIG_fail;
7808 swig_obj[0] = args;
7809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7810 if (!SWIG_IsOK(res1)) {
7811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7812 }
7813 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 delete arg1;
7817
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 resultobj = SWIG_Py_Void();
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj = 0;
7830 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7831 PyObject *arg2 = (PyObject *) 0 ;
7832 void *argp1 = 0 ;
7833 int res1 = 0 ;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "_self", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7844 }
7845 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7846 arg2 = obj1;
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 wxGridTableBase__setOORInfo(arg1,arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7863 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 void *argp2 = 0 ;
7867 int res2 = 0 ;
7868 PyObject * obj0 = 0 ;
7869 PyObject * obj1 = 0 ;
7870 char * kwnames[] = {
7871 (char *) "self",(char *) "attrProvider", NULL
7872 };
7873
7874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7876 if (!SWIG_IsOK(res1)) {
7877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7878 }
7879 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7881 if (!SWIG_IsOK(res2)) {
7882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7883 }
7884 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 (arg1)->SetAttrProvider(arg2);
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7901 wxGridCellAttrProvider *result = 0 ;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7911 }
7912 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7913 {
7914 PyThreadState* __tstate = wxPyBeginAllowThreads();
7915 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7916 wxPyEndAllowThreads(__tstate);
7917 if (PyErr_Occurred()) SWIG_fail;
7918 }
7919 {
7920 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7921 }
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj = 0;
7930 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7931 wxGrid *arg2 = (wxGrid *) 0 ;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 void *argp2 = 0 ;
7935 int res2 = 0 ;
7936 PyObject * obj0 = 0 ;
7937 PyObject * obj1 = 0 ;
7938 char * kwnames[] = {
7939 (char *) "self",(char *) "grid", NULL
7940 };
7941
7942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7946 }
7947 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7949 if (!SWIG_IsOK(res2)) {
7950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7951 }
7952 arg2 = reinterpret_cast< wxGrid * >(argp2);
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 (arg1)->SetView(arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = SWIG_Py_Void();
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7967 PyObject *resultobj = 0;
7968 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7969 wxGrid *result = 0 ;
7970 void *argp1 = 0 ;
7971 int res1 = 0 ;
7972 PyObject *swig_obj[1] ;
7973
7974 if (!args) SWIG_fail;
7975 swig_obj[0] = args;
7976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7977 if (!SWIG_IsOK(res1)) {
7978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7979 }
7980 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 {
7988 resultobj = wxPyMake_wxObject(result, (bool)0);
7989 }
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *resultobj = 0;
7998 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7999 int result;
8000 void *argp1 = 0 ;
8001 int res1 = 0 ;
8002 PyObject *swig_obj[1] ;
8003
8004 if (!args) SWIG_fail;
8005 swig_obj[0] = args;
8006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8007 if (!SWIG_IsOK(res1)) {
8008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8009 }
8010 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (int)(arg1)->GetNumberRows();
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_From_int(static_cast< int >(result));
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *resultobj = 0;
8026 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8027 int result;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 PyObject *swig_obj[1] ;
8031
8032 if (!args) SWIG_fail;
8033 swig_obj[0] = args;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8037 }
8038 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8039 {
8040 PyThreadState* __tstate = wxPyBeginAllowThreads();
8041 result = (int)(arg1)->GetNumberCols();
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 resultobj = SWIG_From_int(static_cast< int >(result));
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8053 PyObject *resultobj = 0;
8054 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8055 int arg2 ;
8056 int arg3 ;
8057 bool result;
8058 void *argp1 = 0 ;
8059 int res1 = 0 ;
8060 int val2 ;
8061 int ecode2 = 0 ;
8062 int val3 ;
8063 int ecode3 = 0 ;
8064 PyObject * obj0 = 0 ;
8065 PyObject * obj1 = 0 ;
8066 PyObject * obj2 = 0 ;
8067 char * kwnames[] = {
8068 (char *) "self",(char *) "row",(char *) "col", NULL
8069 };
8070
8071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8073 if (!SWIG_IsOK(res1)) {
8074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8075 }
8076 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8077 ecode2 = SWIG_AsVal_int(obj1, &val2);
8078 if (!SWIG_IsOK(ecode2)) {
8079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8080 }
8081 arg2 = static_cast< int >(val2);
8082 ecode3 = SWIG_AsVal_int(obj2, &val3);
8083 if (!SWIG_IsOK(ecode3)) {
8084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8085 }
8086 arg3 = static_cast< int >(val3);
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 {
8094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8095 }
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8103 PyObject *resultobj = 0;
8104 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8105 int arg2 ;
8106 int arg3 ;
8107 wxString result;
8108 void *argp1 = 0 ;
8109 int res1 = 0 ;
8110 int val2 ;
8111 int ecode2 = 0 ;
8112 int val3 ;
8113 int ecode3 = 0 ;
8114 PyObject * obj0 = 0 ;
8115 PyObject * obj1 = 0 ;
8116 PyObject * obj2 = 0 ;
8117 char * kwnames[] = {
8118 (char *) "self",(char *) "row",(char *) "col", NULL
8119 };
8120
8121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8123 if (!SWIG_IsOK(res1)) {
8124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8125 }
8126 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8127 ecode2 = SWIG_AsVal_int(obj1, &val2);
8128 if (!SWIG_IsOK(ecode2)) {
8129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8130 }
8131 arg2 = static_cast< int >(val2);
8132 ecode3 = SWIG_AsVal_int(obj2, &val3);
8133 if (!SWIG_IsOK(ecode3)) {
8134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8135 }
8136 arg3 = static_cast< int >(val3);
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 result = (arg1)->GetValue(arg2,arg3);
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj = 0;
8158 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8159 int arg2 ;
8160 int arg3 ;
8161 wxString *arg4 = 0 ;
8162 void *argp1 = 0 ;
8163 int res1 = 0 ;
8164 int val2 ;
8165 int ecode2 = 0 ;
8166 int val3 ;
8167 int ecode3 = 0 ;
8168 bool temp4 = false ;
8169 PyObject * obj0 = 0 ;
8170 PyObject * obj1 = 0 ;
8171 PyObject * obj2 = 0 ;
8172 PyObject * obj3 = 0 ;
8173 char * kwnames[] = {
8174 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8175 };
8176
8177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8179 if (!SWIG_IsOK(res1)) {
8180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8181 }
8182 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8183 ecode2 = SWIG_AsVal_int(obj1, &val2);
8184 if (!SWIG_IsOK(ecode2)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8186 }
8187 arg2 = static_cast< int >(val2);
8188 ecode3 = SWIG_AsVal_int(obj2, &val3);
8189 if (!SWIG_IsOK(ecode3)) {
8190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8191 }
8192 arg3 = static_cast< int >(val3);
8193 {
8194 arg4 = wxString_in_helper(obj3);
8195 if (arg4 == NULL) SWIG_fail;
8196 temp4 = true;
8197 }
8198 {
8199 PyThreadState* __tstate = wxPyBeginAllowThreads();
8200 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 resultobj = SWIG_Py_Void();
8205 {
8206 if (temp4)
8207 delete arg4;
8208 }
8209 return resultobj;
8210 fail:
8211 {
8212 if (temp4)
8213 delete arg4;
8214 }
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj = 0;
8221 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8222 int arg2 ;
8223 int arg3 ;
8224 wxString result;
8225 void *argp1 = 0 ;
8226 int res1 = 0 ;
8227 int val2 ;
8228 int ecode2 = 0 ;
8229 int val3 ;
8230 int ecode3 = 0 ;
8231 PyObject * obj0 = 0 ;
8232 PyObject * obj1 = 0 ;
8233 PyObject * obj2 = 0 ;
8234 char * kwnames[] = {
8235 (char *) "self",(char *) "row",(char *) "col", NULL
8236 };
8237
8238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8240 if (!SWIG_IsOK(res1)) {
8241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8242 }
8243 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8244 ecode2 = SWIG_AsVal_int(obj1, &val2);
8245 if (!SWIG_IsOK(ecode2)) {
8246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8247 }
8248 arg2 = static_cast< int >(val2);
8249 ecode3 = SWIG_AsVal_int(obj2, &val3);
8250 if (!SWIG_IsOK(ecode3)) {
8251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8252 }
8253 arg3 = static_cast< int >(val3);
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = (arg1)->GetTypeName(arg2,arg3);
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 {
8261 #if wxUSE_UNICODE
8262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8263 #else
8264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8265 #endif
8266 }
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8274 PyObject *resultobj = 0;
8275 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8276 int arg2 ;
8277 int arg3 ;
8278 wxString *arg4 = 0 ;
8279 bool result;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 int val2 ;
8283 int ecode2 = 0 ;
8284 int val3 ;
8285 int ecode3 = 0 ;
8286 bool temp4 = false ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 PyObject * obj2 = 0 ;
8290 PyObject * obj3 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8297 if (!SWIG_IsOK(res1)) {
8298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8299 }
8300 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8301 ecode2 = SWIG_AsVal_int(obj1, &val2);
8302 if (!SWIG_IsOK(ecode2)) {
8303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8304 }
8305 arg2 = static_cast< int >(val2);
8306 ecode3 = SWIG_AsVal_int(obj2, &val3);
8307 if (!SWIG_IsOK(ecode3)) {
8308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8309 }
8310 arg3 = static_cast< int >(val3);
8311 {
8312 arg4 = wxString_in_helper(obj3);
8313 if (arg4 == NULL) SWIG_fail;
8314 temp4 = true;
8315 }
8316 {
8317 PyThreadState* __tstate = wxPyBeginAllowThreads();
8318 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8324 }
8325 {
8326 if (temp4)
8327 delete arg4;
8328 }
8329 return resultobj;
8330 fail:
8331 {
8332 if (temp4)
8333 delete arg4;
8334 }
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8342 int arg2 ;
8343 int arg3 ;
8344 wxString *arg4 = 0 ;
8345 bool result;
8346 void *argp1 = 0 ;
8347 int res1 = 0 ;
8348 int val2 ;
8349 int ecode2 = 0 ;
8350 int val3 ;
8351 int ecode3 = 0 ;
8352 bool temp4 = false ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 PyObject * obj2 = 0 ;
8356 PyObject * obj3 = 0 ;
8357 char * kwnames[] = {
8358 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8359 };
8360
8361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8363 if (!SWIG_IsOK(res1)) {
8364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8365 }
8366 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8367 ecode2 = SWIG_AsVal_int(obj1, &val2);
8368 if (!SWIG_IsOK(ecode2)) {
8369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8370 }
8371 arg2 = static_cast< int >(val2);
8372 ecode3 = SWIG_AsVal_int(obj2, &val3);
8373 if (!SWIG_IsOK(ecode3)) {
8374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8375 }
8376 arg3 = static_cast< int >(val3);
8377 {
8378 arg4 = wxString_in_helper(obj3);
8379 if (arg4 == NULL) SWIG_fail;
8380 temp4 = true;
8381 }
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 {
8389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8390 }
8391 {
8392 if (temp4)
8393 delete arg4;
8394 }
8395 return resultobj;
8396 fail:
8397 {
8398 if (temp4)
8399 delete arg4;
8400 }
8401 return NULL;
8402 }
8403
8404
8405 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8406 PyObject *resultobj = 0;
8407 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8408 int arg2 ;
8409 int arg3 ;
8410 long result;
8411 void *argp1 = 0 ;
8412 int res1 = 0 ;
8413 int val2 ;
8414 int ecode2 = 0 ;
8415 int val3 ;
8416 int ecode3 = 0 ;
8417 PyObject * obj0 = 0 ;
8418 PyObject * obj1 = 0 ;
8419 PyObject * obj2 = 0 ;
8420 char * kwnames[] = {
8421 (char *) "self",(char *) "row",(char *) "col", NULL
8422 };
8423
8424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8428 }
8429 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8430 ecode2 = SWIG_AsVal_int(obj1, &val2);
8431 if (!SWIG_IsOK(ecode2)) {
8432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8433 }
8434 arg2 = static_cast< int >(val2);
8435 ecode3 = SWIG_AsVal_int(obj2, &val3);
8436 if (!SWIG_IsOK(ecode3)) {
8437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8438 }
8439 arg3 = static_cast< int >(val3);
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8443 wxPyEndAllowThreads(__tstate);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_From_long(static_cast< long >(result));
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8454 PyObject *resultobj = 0;
8455 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8456 int arg2 ;
8457 int arg3 ;
8458 double result;
8459 void *argp1 = 0 ;
8460 int res1 = 0 ;
8461 int val2 ;
8462 int ecode2 = 0 ;
8463 int val3 ;
8464 int ecode3 = 0 ;
8465 PyObject * obj0 = 0 ;
8466 PyObject * obj1 = 0 ;
8467 PyObject * obj2 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "row",(char *) "col", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8476 }
8477 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8478 ecode2 = SWIG_AsVal_int(obj1, &val2);
8479 if (!SWIG_IsOK(ecode2)) {
8480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8481 }
8482 arg2 = static_cast< int >(val2);
8483 ecode3 = SWIG_AsVal_int(obj2, &val3);
8484 if (!SWIG_IsOK(ecode3)) {
8485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8486 }
8487 arg3 = static_cast< int >(val3);
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 resultobj = SWIG_From_double(static_cast< double >(result));
8495 return resultobj;
8496 fail:
8497 return NULL;
8498 }
8499
8500
8501 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8502 PyObject *resultobj = 0;
8503 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8504 int arg2 ;
8505 int arg3 ;
8506 bool result;
8507 void *argp1 = 0 ;
8508 int res1 = 0 ;
8509 int val2 ;
8510 int ecode2 = 0 ;
8511 int val3 ;
8512 int ecode3 = 0 ;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 PyObject * obj2 = 0 ;
8516 char * kwnames[] = {
8517 (char *) "self",(char *) "row",(char *) "col", NULL
8518 };
8519
8520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8522 if (!SWIG_IsOK(res1)) {
8523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8524 }
8525 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8526 ecode2 = SWIG_AsVal_int(obj1, &val2);
8527 if (!SWIG_IsOK(ecode2)) {
8528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8529 }
8530 arg2 = static_cast< int >(val2);
8531 ecode3 = SWIG_AsVal_int(obj2, &val3);
8532 if (!SWIG_IsOK(ecode3)) {
8533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8534 }
8535 arg3 = static_cast< int >(val3);
8536 {
8537 PyThreadState* __tstate = wxPyBeginAllowThreads();
8538 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 {
8543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8544 }
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj = 0;
8553 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8554 int arg2 ;
8555 int arg3 ;
8556 long arg4 ;
8557 void *argp1 = 0 ;
8558 int res1 = 0 ;
8559 int val2 ;
8560 int ecode2 = 0 ;
8561 int val3 ;
8562 int ecode3 = 0 ;
8563 long val4 ;
8564 int ecode4 = 0 ;
8565 PyObject * obj0 = 0 ;
8566 PyObject * obj1 = 0 ;
8567 PyObject * obj2 = 0 ;
8568 PyObject * obj3 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8577 }
8578 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8579 ecode2 = SWIG_AsVal_int(obj1, &val2);
8580 if (!SWIG_IsOK(ecode2)) {
8581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8582 }
8583 arg2 = static_cast< int >(val2);
8584 ecode3 = SWIG_AsVal_int(obj2, &val3);
8585 if (!SWIG_IsOK(ecode3)) {
8586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8587 }
8588 arg3 = static_cast< int >(val3);
8589 ecode4 = SWIG_AsVal_long(obj3, &val4);
8590 if (!SWIG_IsOK(ecode4)) {
8591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8592 }
8593 arg4 = static_cast< long >(val4);
8594 {
8595 PyThreadState* __tstate = wxPyBeginAllowThreads();
8596 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8597 wxPyEndAllowThreads(__tstate);
8598 if (PyErr_Occurred()) SWIG_fail;
8599 }
8600 resultobj = SWIG_Py_Void();
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj = 0;
8609 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8610 int arg2 ;
8611 int arg3 ;
8612 double arg4 ;
8613 void *argp1 = 0 ;
8614 int res1 = 0 ;
8615 int val2 ;
8616 int ecode2 = 0 ;
8617 int val3 ;
8618 int ecode3 = 0 ;
8619 double val4 ;
8620 int ecode4 = 0 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 PyObject * obj2 = 0 ;
8624 PyObject * obj3 = 0 ;
8625 char * kwnames[] = {
8626 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8627 };
8628
8629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8631 if (!SWIG_IsOK(res1)) {
8632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8633 }
8634 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8635 ecode2 = SWIG_AsVal_int(obj1, &val2);
8636 if (!SWIG_IsOK(ecode2)) {
8637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8638 }
8639 arg2 = static_cast< int >(val2);
8640 ecode3 = SWIG_AsVal_int(obj2, &val3);
8641 if (!SWIG_IsOK(ecode3)) {
8642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8643 }
8644 arg3 = static_cast< int >(val3);
8645 ecode4 = SWIG_AsVal_double(obj3, &val4);
8646 if (!SWIG_IsOK(ecode4)) {
8647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8648 }
8649 arg4 = static_cast< double >(val4);
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 resultobj = SWIG_Py_Void();
8657 return resultobj;
8658 fail:
8659 return NULL;
8660 }
8661
8662
8663 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8664 PyObject *resultobj = 0;
8665 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8666 int arg2 ;
8667 int arg3 ;
8668 bool arg4 ;
8669 void *argp1 = 0 ;
8670 int res1 = 0 ;
8671 int val2 ;
8672 int ecode2 = 0 ;
8673 int val3 ;
8674 int ecode3 = 0 ;
8675 bool val4 ;
8676 int ecode4 = 0 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 PyObject * obj2 = 0 ;
8680 PyObject * obj3 = 0 ;
8681 char * kwnames[] = {
8682 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8683 };
8684
8685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8689 }
8690 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8691 ecode2 = SWIG_AsVal_int(obj1, &val2);
8692 if (!SWIG_IsOK(ecode2)) {
8693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8694 }
8695 arg2 = static_cast< int >(val2);
8696 ecode3 = SWIG_AsVal_int(obj2, &val3);
8697 if (!SWIG_IsOK(ecode3)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8699 }
8700 arg3 = static_cast< int >(val3);
8701 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8702 if (!SWIG_IsOK(ecode4)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8704 }
8705 arg4 = static_cast< bool >(val4);
8706 {
8707 PyThreadState* __tstate = wxPyBeginAllowThreads();
8708 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_Py_Void();
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8720 PyObject *resultobj = 0;
8721 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 PyObject *swig_obj[1] ;
8725
8726 if (!args) SWIG_fail;
8727 swig_obj[0] = args;
8728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8729 if (!SWIG_IsOK(res1)) {
8730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8731 }
8732 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 (arg1)->Clear();
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 resultobj = SWIG_Py_Void();
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8749 size_t arg2 = (size_t) 0 ;
8750 size_t arg3 = (size_t) 1 ;
8751 bool result;
8752 void *argp1 = 0 ;
8753 int res1 = 0 ;
8754 size_t val2 ;
8755 int ecode2 = 0 ;
8756 size_t val3 ;
8757 int ecode3 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 PyObject * obj2 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8769 }
8770 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8771 if (obj1) {
8772 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8773 if (!SWIG_IsOK(ecode2)) {
8774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8775 }
8776 arg2 = static_cast< size_t >(val2);
8777 }
8778 if (obj2) {
8779 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8780 if (!SWIG_IsOK(ecode3)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8782 }
8783 arg3 = static_cast< size_t >(val3);
8784 }
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 result = (bool)(arg1)->InsertRows(arg2,arg3);
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8801 PyObject *resultobj = 0;
8802 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8803 size_t arg2 = (size_t) 1 ;
8804 bool result;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 size_t val2 ;
8808 int ecode2 = 0 ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "self",(char *) "numRows", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8817 if (!SWIG_IsOK(res1)) {
8818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8819 }
8820 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8821 if (obj1) {
8822 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8823 if (!SWIG_IsOK(ecode2)) {
8824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8825 }
8826 arg2 = static_cast< size_t >(val2);
8827 }
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 result = (bool)(arg1)->AppendRows(arg2);
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 {
8835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj = 0;
8845 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8846 size_t arg2 = (size_t) 0 ;
8847 size_t arg3 = (size_t) 1 ;
8848 bool result;
8849 void *argp1 = 0 ;
8850 int res1 = 0 ;
8851 size_t val2 ;
8852 int ecode2 = 0 ;
8853 size_t val3 ;
8854 int ecode3 = 0 ;
8855 PyObject * obj0 = 0 ;
8856 PyObject * obj1 = 0 ;
8857 PyObject * obj2 = 0 ;
8858 char * kwnames[] = {
8859 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8860 };
8861
8862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8864 if (!SWIG_IsOK(res1)) {
8865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8866 }
8867 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8868 if (obj1) {
8869 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8872 }
8873 arg2 = static_cast< size_t >(val2);
8874 }
8875 if (obj2) {
8876 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8877 if (!SWIG_IsOK(ecode3)) {
8878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8879 }
8880 arg3 = static_cast< size_t >(val3);
8881 }
8882 {
8883 PyThreadState* __tstate = wxPyBeginAllowThreads();
8884 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8885 wxPyEndAllowThreads(__tstate);
8886 if (PyErr_Occurred()) SWIG_fail;
8887 }
8888 {
8889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8890 }
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj = 0;
8899 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8900 size_t arg2 = (size_t) 0 ;
8901 size_t arg3 = (size_t) 1 ;
8902 bool result;
8903 void *argp1 = 0 ;
8904 int res1 = 0 ;
8905 size_t val2 ;
8906 int ecode2 = 0 ;
8907 size_t val3 ;
8908 int ecode3 = 0 ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 PyObject * obj2 = 0 ;
8912 char * kwnames[] = {
8913 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8914 };
8915
8916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8918 if (!SWIG_IsOK(res1)) {
8919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8920 }
8921 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8922 if (obj1) {
8923 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8924 if (!SWIG_IsOK(ecode2)) {
8925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8926 }
8927 arg2 = static_cast< size_t >(val2);
8928 }
8929 if (obj2) {
8930 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8931 if (!SWIG_IsOK(ecode3)) {
8932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8933 }
8934 arg3 = static_cast< size_t >(val3);
8935 }
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = (bool)(arg1)->InsertCols(arg2,arg3);
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8944 }
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8952 PyObject *resultobj = 0;
8953 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8954 size_t arg2 = (size_t) 1 ;
8955 bool result;
8956 void *argp1 = 0 ;
8957 int res1 = 0 ;
8958 size_t val2 ;
8959 int ecode2 = 0 ;
8960 PyObject * obj0 = 0 ;
8961 PyObject * obj1 = 0 ;
8962 char * kwnames[] = {
8963 (char *) "self",(char *) "numCols", NULL
8964 };
8965
8966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8970 }
8971 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8972 if (obj1) {
8973 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8974 if (!SWIG_IsOK(ecode2)) {
8975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8976 }
8977 arg2 = static_cast< size_t >(val2);
8978 }
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 result = (bool)(arg1)->AppendCols(arg2);
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 {
8986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8987 }
8988 return resultobj;
8989 fail:
8990 return NULL;
8991 }
8992
8993
8994 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8995 PyObject *resultobj = 0;
8996 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8997 size_t arg2 = (size_t) 0 ;
8998 size_t arg3 = (size_t) 1 ;
8999 bool result;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 size_t val2 ;
9003 int ecode2 = 0 ;
9004 size_t val3 ;
9005 int ecode3 = 0 ;
9006 PyObject * obj0 = 0 ;
9007 PyObject * obj1 = 0 ;
9008 PyObject * obj2 = 0 ;
9009 char * kwnames[] = {
9010 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9011 };
9012
9013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9015 if (!SWIG_IsOK(res1)) {
9016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9017 }
9018 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9019 if (obj1) {
9020 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9021 if (!SWIG_IsOK(ecode2)) {
9022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9023 }
9024 arg2 = static_cast< size_t >(val2);
9025 }
9026 if (obj2) {
9027 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9028 if (!SWIG_IsOK(ecode3)) {
9029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9030 }
9031 arg3 = static_cast< size_t >(val3);
9032 }
9033 {
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9036 wxPyEndAllowThreads(__tstate);
9037 if (PyErr_Occurred()) SWIG_fail;
9038 }
9039 {
9040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9041 }
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9049 PyObject *resultobj = 0;
9050 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9051 int arg2 ;
9052 wxString result;
9053 void *argp1 = 0 ;
9054 int res1 = 0 ;
9055 int val2 ;
9056 int ecode2 = 0 ;
9057 PyObject * obj0 = 0 ;
9058 PyObject * obj1 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "row", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9067 }
9068 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9069 ecode2 = SWIG_AsVal_int(obj1, &val2);
9070 if (!SWIG_IsOK(ecode2)) {
9071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9072 }
9073 arg2 = static_cast< int >(val2);
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 result = (arg1)->GetRowLabelValue(arg2);
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 {
9081 #if wxUSE_UNICODE
9082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9083 #else
9084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9085 #endif
9086 }
9087 return resultobj;
9088 fail:
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9094 PyObject *resultobj = 0;
9095 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9096 int arg2 ;
9097 wxString result;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 int val2 ;
9101 int ecode2 = 0 ;
9102 PyObject * obj0 = 0 ;
9103 PyObject * obj1 = 0 ;
9104 char * kwnames[] = {
9105 (char *) "self",(char *) "col", NULL
9106 };
9107
9108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9110 if (!SWIG_IsOK(res1)) {
9111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9112 }
9113 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9114 ecode2 = SWIG_AsVal_int(obj1, &val2);
9115 if (!SWIG_IsOK(ecode2)) {
9116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9117 }
9118 arg2 = static_cast< int >(val2);
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 result = (arg1)->GetColLabelValue(arg2);
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 {
9126 #if wxUSE_UNICODE
9127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9128 #else
9129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9130 #endif
9131 }
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9139 PyObject *resultobj = 0;
9140 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9141 int arg2 ;
9142 wxString *arg3 = 0 ;
9143 void *argp1 = 0 ;
9144 int res1 = 0 ;
9145 int val2 ;
9146 int ecode2 = 0 ;
9147 bool temp3 = false ;
9148 PyObject * obj0 = 0 ;
9149 PyObject * obj1 = 0 ;
9150 PyObject * obj2 = 0 ;
9151 char * kwnames[] = {
9152 (char *) "self",(char *) "row",(char *) "value", NULL
9153 };
9154
9155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9159 }
9160 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9161 ecode2 = SWIG_AsVal_int(obj1, &val2);
9162 if (!SWIG_IsOK(ecode2)) {
9163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9164 }
9165 arg2 = static_cast< int >(val2);
9166 {
9167 arg3 = wxString_in_helper(obj2);
9168 if (arg3 == NULL) SWIG_fail;
9169 temp3 = true;
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 resultobj = SWIG_Py_Void();
9178 {
9179 if (temp3)
9180 delete arg3;
9181 }
9182 return resultobj;
9183 fail:
9184 {
9185 if (temp3)
9186 delete arg3;
9187 }
9188 return NULL;
9189 }
9190
9191
9192 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj = 0;
9194 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9195 int arg2 ;
9196 wxString *arg3 = 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 int val2 ;
9200 int ecode2 = 0 ;
9201 bool temp3 = false ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 PyObject * obj2 = 0 ;
9205 char * kwnames[] = {
9206 (char *) "self",(char *) "col",(char *) "value", NULL
9207 };
9208
9209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9211 if (!SWIG_IsOK(res1)) {
9212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9213 }
9214 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9215 ecode2 = SWIG_AsVal_int(obj1, &val2);
9216 if (!SWIG_IsOK(ecode2)) {
9217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9218 }
9219 arg2 = static_cast< int >(val2);
9220 {
9221 arg3 = wxString_in_helper(obj2);
9222 if (arg3 == NULL) SWIG_fail;
9223 temp3 = true;
9224 }
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_Py_Void();
9232 {
9233 if (temp3)
9234 delete arg3;
9235 }
9236 return resultobj;
9237 fail:
9238 {
9239 if (temp3)
9240 delete arg3;
9241 }
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9247 PyObject *resultobj = 0;
9248 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9249 bool result;
9250 void *argp1 = 0 ;
9251 int res1 = 0 ;
9252 PyObject *swig_obj[1] ;
9253
9254 if (!args) SWIG_fail;
9255 swig_obj[0] = args;
9256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9257 if (!SWIG_IsOK(res1)) {
9258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9259 }
9260 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 result = (bool)(arg1)->CanHaveAttributes();
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 {
9268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9269 }
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj = 0;
9278 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9279 int arg2 ;
9280 int arg3 ;
9281 wxGridCellAttr::wxAttrKind arg4 ;
9282 wxGridCellAttr *result = 0 ;
9283 void *argp1 = 0 ;
9284 int res1 = 0 ;
9285 int val2 ;
9286 int ecode2 = 0 ;
9287 int val3 ;
9288 int ecode3 = 0 ;
9289 int val4 ;
9290 int ecode4 = 0 ;
9291 PyObject * obj0 = 0 ;
9292 PyObject * obj1 = 0 ;
9293 PyObject * obj2 = 0 ;
9294 PyObject * obj3 = 0 ;
9295 char * kwnames[] = {
9296 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9297 };
9298
9299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9303 }
9304 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9305 ecode2 = SWIG_AsVal_int(obj1, &val2);
9306 if (!SWIG_IsOK(ecode2)) {
9307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9308 }
9309 arg2 = static_cast< int >(val2);
9310 ecode3 = SWIG_AsVal_int(obj2, &val3);
9311 if (!SWIG_IsOK(ecode3)) {
9312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9313 }
9314 arg3 = static_cast< int >(val3);
9315 ecode4 = SWIG_AsVal_int(obj3, &val4);
9316 if (!SWIG_IsOK(ecode4)) {
9317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9318 }
9319 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 {
9327 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9328 }
9329 return resultobj;
9330 fail:
9331 return NULL;
9332 }
9333
9334
9335 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj = 0;
9337 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9338 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9339 int arg3 ;
9340 int arg4 ;
9341 void *argp1 = 0 ;
9342 int res1 = 0 ;
9343 void *argp2 = 0 ;
9344 int res2 = 0 ;
9345 int val3 ;
9346 int ecode3 = 0 ;
9347 int val4 ;
9348 int ecode4 = 0 ;
9349 PyObject * obj0 = 0 ;
9350 PyObject * obj1 = 0 ;
9351 PyObject * obj2 = 0 ;
9352 PyObject * obj3 = 0 ;
9353 char * kwnames[] = {
9354 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9355 };
9356
9357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9359 if (!SWIG_IsOK(res1)) {
9360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9361 }
9362 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9364 if (!SWIG_IsOK(res2)) {
9365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9366 }
9367 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9368 ecode3 = SWIG_AsVal_int(obj2, &val3);
9369 if (!SWIG_IsOK(ecode3)) {
9370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9371 }
9372 arg3 = static_cast< int >(val3);
9373 ecode4 = SWIG_AsVal_int(obj3, &val4);
9374 if (!SWIG_IsOK(ecode4)) {
9375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9376 }
9377 arg4 = static_cast< int >(val4);
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 (arg1)->SetAttr(arg2,arg3,arg4);
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 resultobj = SWIG_Py_Void();
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9392 PyObject *resultobj = 0;
9393 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9394 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9395 int arg3 ;
9396 void *argp1 = 0 ;
9397 int res1 = 0 ;
9398 void *argp2 = 0 ;
9399 int res2 = 0 ;
9400 int val3 ;
9401 int ecode3 = 0 ;
9402 PyObject * obj0 = 0 ;
9403 PyObject * obj1 = 0 ;
9404 PyObject * obj2 = 0 ;
9405 char * kwnames[] = {
9406 (char *) "self",(char *) "attr",(char *) "row", NULL
9407 };
9408
9409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9413 }
9414 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9416 if (!SWIG_IsOK(res2)) {
9417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9418 }
9419 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9420 ecode3 = SWIG_AsVal_int(obj2, &val3);
9421 if (!SWIG_IsOK(ecode3)) {
9422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9423 }
9424 arg3 = static_cast< int >(val3);
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 (arg1)->SetRowAttr(arg2,arg3);
9428 wxPyEndAllowThreads(__tstate);
9429 if (PyErr_Occurred()) SWIG_fail;
9430 }
9431 resultobj = SWIG_Py_Void();
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj = 0;
9440 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9441 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9442 int arg3 ;
9443 void *argp1 = 0 ;
9444 int res1 = 0 ;
9445 void *argp2 = 0 ;
9446 int res2 = 0 ;
9447 int val3 ;
9448 int ecode3 = 0 ;
9449 PyObject * obj0 = 0 ;
9450 PyObject * obj1 = 0 ;
9451 PyObject * obj2 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "attr",(char *) "col", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9460 }
9461 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9463 if (!SWIG_IsOK(res2)) {
9464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9465 }
9466 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9467 ecode3 = SWIG_AsVal_int(obj2, &val3);
9468 if (!SWIG_IsOK(ecode3)) {
9469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9470 }
9471 arg3 = static_cast< int >(val3);
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 (arg1)->SetColAttr(arg2,arg3);
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_Py_Void();
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9486 PyObject *obj;
9487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9488 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9489 return SWIG_Py_Void();
9490 }
9491
9492 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9493 PyObject *resultobj = 0;
9494 wxPyGridTableBase *result = 0 ;
9495
9496 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj = 0;
9512 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9513 PyObject *arg2 = (PyObject *) 0 ;
9514 PyObject *arg3 = (PyObject *) 0 ;
9515 void *argp1 = 0 ;
9516 int res1 = 0 ;
9517 PyObject * obj0 = 0 ;
9518 PyObject * obj1 = 0 ;
9519 PyObject * obj2 = 0 ;
9520 char * kwnames[] = {
9521 (char *) "self",(char *) "self",(char *) "_class", NULL
9522 };
9523
9524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9528 }
9529 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9530 arg2 = obj1;
9531 arg3 = obj2;
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 (arg1)->_setCallbackInfo(arg2,arg3);
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_Py_Void();
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9546 PyObject *resultobj = 0;
9547 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 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_wxPyGridTableBase, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9557 }
9558 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 wxPyGridTableBase_Destroy(arg1);
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_Py_Void();
9566 return resultobj;
9567 fail:
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 PyObject *obj;
9574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9575 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9576 return SWIG_Py_Void();
9577 }
9578
9579 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9580 return SWIG_Python_InitShadowInstance(args);
9581 }
9582
9583 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 int arg1 = (int) 0 ;
9586 int arg2 = (int) 0 ;
9587 wxGridStringTable *result = 0 ;
9588 int val1 ;
9589 int ecode1 = 0 ;
9590 int val2 ;
9591 int ecode2 = 0 ;
9592 PyObject * obj0 = 0 ;
9593 PyObject * obj1 = 0 ;
9594 char * kwnames[] = {
9595 (char *) "numRows",(char *) "numCols", NULL
9596 };
9597
9598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9599 if (obj0) {
9600 ecode1 = SWIG_AsVal_int(obj0, &val1);
9601 if (!SWIG_IsOK(ecode1)) {
9602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9603 }
9604 arg1 = static_cast< int >(val1);
9605 }
9606 if (obj1) {
9607 ecode2 = SWIG_AsVal_int(obj1, &val2);
9608 if (!SWIG_IsOK(ecode2)) {
9609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9610 }
9611 arg2 = static_cast< int >(val2);
9612 }
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9627 PyObject *obj;
9628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9629 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9630 return SWIG_Py_Void();
9631 }
9632
9633 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9634 return SWIG_Python_InitShadowInstance(args);
9635 }
9636
9637 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj = 0;
9639 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9640 int arg2 ;
9641 int arg3 = (int) -1 ;
9642 int arg4 = (int) -1 ;
9643 wxGridTableMessage *result = 0 ;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 int val2 ;
9647 int ecode2 = 0 ;
9648 int val3 ;
9649 int ecode3 = 0 ;
9650 int val4 ;
9651 int ecode4 = 0 ;
9652 PyObject * obj0 = 0 ;
9653 PyObject * obj1 = 0 ;
9654 PyObject * obj2 = 0 ;
9655 PyObject * obj3 = 0 ;
9656 char * kwnames[] = {
9657 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9658 };
9659
9660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9664 }
9665 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9666 ecode2 = SWIG_AsVal_int(obj1, &val2);
9667 if (!SWIG_IsOK(ecode2)) {
9668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9669 }
9670 arg2 = static_cast< int >(val2);
9671 if (obj2) {
9672 ecode3 = SWIG_AsVal_int(obj2, &val3);
9673 if (!SWIG_IsOK(ecode3)) {
9674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9675 }
9676 arg3 = static_cast< int >(val3);
9677 }
9678 if (obj3) {
9679 ecode4 = SWIG_AsVal_int(obj3, &val4);
9680 if (!SWIG_IsOK(ecode4)) {
9681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9682 }
9683 arg4 = static_cast< int >(val4);
9684 }
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9699 PyObject *resultobj = 0;
9700 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 PyObject *swig_obj[1] ;
9704
9705 if (!args) SWIG_fail;
9706 swig_obj[0] = args;
9707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9708 if (!SWIG_IsOK(res1)) {
9709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9710 }
9711 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 delete arg1;
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 resultobj = SWIG_Py_Void();
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9727 PyObject *resultobj = 0;
9728 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9729 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 void *argp2 = 0 ;
9733 int res2 = 0 ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 char * kwnames[] = {
9737 (char *) "self",(char *) "table", NULL
9738 };
9739
9740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9742 if (!SWIG_IsOK(res1)) {
9743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9744 }
9745 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9747 if (!SWIG_IsOK(res2)) {
9748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9749 }
9750 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9751 {
9752 PyThreadState* __tstate = wxPyBeginAllowThreads();
9753 (arg1)->SetTableObject(arg2);
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 resultobj = SWIG_Py_Void();
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9765 PyObject *resultobj = 0;
9766 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9767 wxGridTableBase *result = 0 ;
9768 void *argp1 = 0 ;
9769 int res1 = 0 ;
9770 PyObject *swig_obj[1] ;
9771
9772 if (!args) SWIG_fail;
9773 swig_obj[0] = args;
9774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9775 if (!SWIG_IsOK(res1)) {
9776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9777 }
9778 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9779 {
9780 PyThreadState* __tstate = wxPyBeginAllowThreads();
9781 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 {
9786 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9787 }
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj = 0;
9796 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9797 int arg2 ;
9798 void *argp1 = 0 ;
9799 int res1 = 0 ;
9800 int val2 ;
9801 int ecode2 = 0 ;
9802 PyObject * obj0 = 0 ;
9803 PyObject * obj1 = 0 ;
9804 char * kwnames[] = {
9805 (char *) "self",(char *) "id", NULL
9806 };
9807
9808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9810 if (!SWIG_IsOK(res1)) {
9811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9812 }
9813 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9814 ecode2 = SWIG_AsVal_int(obj1, &val2);
9815 if (!SWIG_IsOK(ecode2)) {
9816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9817 }
9818 arg2 = static_cast< int >(val2);
9819 {
9820 PyThreadState* __tstate = wxPyBeginAllowThreads();
9821 (arg1)->SetId(arg2);
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_Py_Void();
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9835 int result;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9845 }
9846 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 result = (int)(arg1)->GetId();
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 resultobj = SWIG_From_int(static_cast< int >(result));
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj = 0;
9862 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9863 int arg2 ;
9864 void *argp1 = 0 ;
9865 int res1 = 0 ;
9866 int val2 ;
9867 int ecode2 = 0 ;
9868 PyObject * obj0 = 0 ;
9869 PyObject * obj1 = 0 ;
9870 char * kwnames[] = {
9871 (char *) "self",(char *) "comInt1", NULL
9872 };
9873
9874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9878 }
9879 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9880 ecode2 = SWIG_AsVal_int(obj1, &val2);
9881 if (!SWIG_IsOK(ecode2)) {
9882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9883 }
9884 arg2 = static_cast< int >(val2);
9885 {
9886 PyThreadState* __tstate = wxPyBeginAllowThreads();
9887 (arg1)->SetCommandInt(arg2);
9888 wxPyEndAllowThreads(__tstate);
9889 if (PyErr_Occurred()) SWIG_fail;
9890 }
9891 resultobj = SWIG_Py_Void();
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 PyObject *resultobj = 0;
9900 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9901 int result;
9902 void *argp1 = 0 ;
9903 int res1 = 0 ;
9904 PyObject *swig_obj[1] ;
9905
9906 if (!args) SWIG_fail;
9907 swig_obj[0] = args;
9908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9911 }
9912 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (int)(arg1)->GetCommandInt();
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_From_int(static_cast< int >(result));
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj = 0;
9928 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9929 int arg2 ;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 int val2 ;
9933 int ecode2 = 0 ;
9934 PyObject * obj0 = 0 ;
9935 PyObject * obj1 = 0 ;
9936 char * kwnames[] = {
9937 (char *) "self",(char *) "comInt2", NULL
9938 };
9939
9940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9942 if (!SWIG_IsOK(res1)) {
9943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9944 }
9945 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9946 ecode2 = SWIG_AsVal_int(obj1, &val2);
9947 if (!SWIG_IsOK(ecode2)) {
9948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9949 }
9950 arg2 = static_cast< int >(val2);
9951 {
9952 PyThreadState* __tstate = wxPyBeginAllowThreads();
9953 (arg1)->SetCommandInt2(arg2);
9954 wxPyEndAllowThreads(__tstate);
9955 if (PyErr_Occurred()) SWIG_fail;
9956 }
9957 resultobj = SWIG_Py_Void();
9958 return resultobj;
9959 fail:
9960 return NULL;
9961 }
9962
9963
9964 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9965 PyObject *resultobj = 0;
9966 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9967 int result;
9968 void *argp1 = 0 ;
9969 int res1 = 0 ;
9970 PyObject *swig_obj[1] ;
9971
9972 if (!args) SWIG_fail;
9973 swig_obj[0] = args;
9974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9975 if (!SWIG_IsOK(res1)) {
9976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9977 }
9978 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 result = (int)(arg1)->GetCommandInt2();
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 resultobj = SWIG_From_int(static_cast< int >(result));
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *obj;
9994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9995 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9996 return SWIG_Py_Void();
9997 }
9998
9999 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10000 return SWIG_Python_InitShadowInstance(args);
10001 }
10002
10003 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj = 0;
10005 int arg1 = (int) -1 ;
10006 int arg2 = (int) -1 ;
10007 wxGridCellCoords *result = 0 ;
10008 int val1 ;
10009 int ecode1 = 0 ;
10010 int val2 ;
10011 int ecode2 = 0 ;
10012 PyObject * obj0 = 0 ;
10013 PyObject * obj1 = 0 ;
10014 char * kwnames[] = {
10015 (char *) "r",(char *) "c", NULL
10016 };
10017
10018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10019 if (obj0) {
10020 ecode1 = SWIG_AsVal_int(obj0, &val1);
10021 if (!SWIG_IsOK(ecode1)) {
10022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10023 }
10024 arg1 = static_cast< int >(val1);
10025 }
10026 if (obj1) {
10027 ecode2 = SWIG_AsVal_int(obj1, &val2);
10028 if (!SWIG_IsOK(ecode2)) {
10029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10030 }
10031 arg2 = static_cast< int >(val2);
10032 }
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10036 wxPyEndAllowThreads(__tstate);
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10040 return resultobj;
10041 fail:
10042 return NULL;
10043 }
10044
10045
10046 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10047 PyObject *resultobj = 0;
10048 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 PyObject *swig_obj[1] ;
10052
10053 if (!args) SWIG_fail;
10054 swig_obj[0] = args;
10055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10058 }
10059 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10060 {
10061 PyThreadState* __tstate = wxPyBeginAllowThreads();
10062 delete arg1;
10063
10064 wxPyEndAllowThreads(__tstate);
10065 if (PyErr_Occurred()) SWIG_fail;
10066 }
10067 resultobj = SWIG_Py_Void();
10068 return resultobj;
10069 fail:
10070 return NULL;
10071 }
10072
10073
10074 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10075 PyObject *resultobj = 0;
10076 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10077 int result;
10078 void *argp1 = 0 ;
10079 int res1 = 0 ;
10080 PyObject *swig_obj[1] ;
10081
10082 if (!args) SWIG_fail;
10083 swig_obj[0] = args;
10084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10085 if (!SWIG_IsOK(res1)) {
10086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10087 }
10088 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_From_int(static_cast< int >(result));
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10105 int arg2 ;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 int val2 ;
10109 int ecode2 = 0 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "n", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10120 }
10121 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10122 ecode2 = SWIG_AsVal_int(obj1, &val2);
10123 if (!SWIG_IsOK(ecode2)) {
10124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10125 }
10126 arg2 = static_cast< int >(val2);
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 (arg1)->SetRow(arg2);
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 resultobj = SWIG_Py_Void();
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 PyObject *resultobj = 0;
10142 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10143 int result;
10144 void *argp1 = 0 ;
10145 int res1 = 0 ;
10146 PyObject *swig_obj[1] ;
10147
10148 if (!args) SWIG_fail;
10149 swig_obj[0] = args;
10150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10151 if (!SWIG_IsOK(res1)) {
10152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10153 }
10154 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 resultobj = SWIG_From_int(static_cast< int >(result));
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj = 0;
10170 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10171 int arg2 ;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 int val2 ;
10175 int ecode2 = 0 ;
10176 PyObject * obj0 = 0 ;
10177 PyObject * obj1 = 0 ;
10178 char * kwnames[] = {
10179 (char *) "self",(char *) "n", NULL
10180 };
10181
10182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10186 }
10187 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10188 ecode2 = SWIG_AsVal_int(obj1, &val2);
10189 if (!SWIG_IsOK(ecode2)) {
10190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10191 }
10192 arg2 = static_cast< int >(val2);
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 (arg1)->SetCol(arg2);
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 resultobj = SWIG_Py_Void();
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj = 0;
10208 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10209 int arg2 ;
10210 int arg3 ;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 int val2 ;
10214 int ecode2 = 0 ;
10215 int val3 ;
10216 int ecode3 = 0 ;
10217 PyObject * obj0 = 0 ;
10218 PyObject * obj1 = 0 ;
10219 PyObject * obj2 = 0 ;
10220 char * kwnames[] = {
10221 (char *) "self",(char *) "row",(char *) "col", NULL
10222 };
10223
10224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10228 }
10229 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10230 ecode2 = SWIG_AsVal_int(obj1, &val2);
10231 if (!SWIG_IsOK(ecode2)) {
10232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10233 }
10234 arg2 = static_cast< int >(val2);
10235 ecode3 = SWIG_AsVal_int(obj2, &val3);
10236 if (!SWIG_IsOK(ecode3)) {
10237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10238 }
10239 arg3 = static_cast< int >(val3);
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 (arg1)->Set(arg2,arg3);
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 resultobj = SWIG_Py_Void();
10247 return resultobj;
10248 fail:
10249 return NULL;
10250 }
10251
10252
10253 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj = 0;
10255 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10256 PyObject *arg2 = (PyObject *) 0 ;
10257 bool result;
10258 void *argp1 = 0 ;
10259 int res1 = 0 ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char * kwnames[] = {
10263 (char *) "self",(char *) "other", NULL
10264 };
10265
10266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10270 }
10271 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10272 arg2 = obj1;
10273 {
10274 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10279 }
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10289 PyObject *arg2 = (PyObject *) 0 ;
10290 bool result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 PyObject * obj0 = 0 ;
10294 PyObject * obj1 = 0 ;
10295 char * kwnames[] = {
10296 (char *) "self",(char *) "other", NULL
10297 };
10298
10299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10301 if (!SWIG_IsOK(res1)) {
10302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10303 }
10304 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10305 arg2 = obj1;
10306 {
10307 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 {
10311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10312 }
10313 return resultobj;
10314 fail:
10315 return NULL;
10316 }
10317
10318
10319 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10320 PyObject *resultobj = 0;
10321 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10322 PyObject *result = 0 ;
10323 void *argp1 = 0 ;
10324 int res1 = 0 ;
10325 PyObject *swig_obj[1] ;
10326
10327 if (!args) SWIG_fail;
10328 swig_obj[0] = args;
10329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10330 if (!SWIG_IsOK(res1)) {
10331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10332 }
10333 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (PyObject *)wxGridCellCoords_Get(arg1);
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = result;
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10348 PyObject *obj;
10349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10350 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10351 return SWIG_Py_Void();
10352 }
10353
10354 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10355 return SWIG_Python_InitShadowInstance(args);
10356 }
10357
10358 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj = 0;
10360 wxWindow *arg1 = (wxWindow *) 0 ;
10361 int arg2 = (int) -1 ;
10362 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10363 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10364 wxSize const &arg4_defvalue = wxDefaultSize ;
10365 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10366 long arg5 = (long) wxWANTS_CHARS ;
10367 wxString const &arg6_defvalue = wxPyGridNameStr ;
10368 wxString *arg6 = (wxString *) &arg6_defvalue ;
10369 wxGrid *result = 0 ;
10370 void *argp1 = 0 ;
10371 int res1 = 0 ;
10372 int val2 ;
10373 int ecode2 = 0 ;
10374 wxPoint temp3 ;
10375 wxSize temp4 ;
10376 long val5 ;
10377 int ecode5 = 0 ;
10378 bool temp6 = false ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 PyObject * obj2 = 0 ;
10382 PyObject * obj3 = 0 ;
10383 PyObject * obj4 = 0 ;
10384 PyObject * obj5 = 0 ;
10385 char * kwnames[] = {
10386 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10387 };
10388
10389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10391 if (!SWIG_IsOK(res1)) {
10392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10393 }
10394 arg1 = reinterpret_cast< wxWindow * >(argp1);
10395 if (obj1) {
10396 ecode2 = SWIG_AsVal_int(obj1, &val2);
10397 if (!SWIG_IsOK(ecode2)) {
10398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10399 }
10400 arg2 = static_cast< int >(val2);
10401 }
10402 if (obj2) {
10403 {
10404 arg3 = &temp3;
10405 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10406 }
10407 }
10408 if (obj3) {
10409 {
10410 arg4 = &temp4;
10411 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10412 }
10413 }
10414 if (obj4) {
10415 ecode5 = SWIG_AsVal_long(obj4, &val5);
10416 if (!SWIG_IsOK(ecode5)) {
10417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10418 }
10419 arg5 = static_cast< long >(val5);
10420 }
10421 if (obj5) {
10422 {
10423 arg6 = wxString_in_helper(obj5);
10424 if (arg6 == NULL) SWIG_fail;
10425 temp6 = true;
10426 }
10427 }
10428 {
10429 if (!wxPyCheckForApp()) SWIG_fail;
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10432 wxPyEndAllowThreads(__tstate);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10436 {
10437 if (temp6)
10438 delete arg6;
10439 }
10440 return resultobj;
10441 fail:
10442 {
10443 if (temp6)
10444 delete arg6;
10445 }
10446 return NULL;
10447 }
10448
10449
10450 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10451 PyObject *resultobj = 0;
10452 wxGrid *result = 0 ;
10453
10454 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10455 {
10456 if (!wxPyCheckForApp()) SWIG_fail;
10457 PyThreadState* __tstate = wxPyBeginAllowThreads();
10458 result = (wxGrid *)new wxGrid();
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10470 PyObject *resultobj = 0;
10471 wxGrid *arg1 = (wxGrid *) 0 ;
10472 wxWindow *arg2 = (wxWindow *) 0 ;
10473 int arg3 = (int) -1 ;
10474 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10475 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10476 wxSize const &arg5_defvalue = wxDefaultSize ;
10477 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10478 long arg6 = (long) wxWANTS_CHARS ;
10479 wxString const &arg7_defvalue = wxPyGridNameStr ;
10480 wxString *arg7 = (wxString *) &arg7_defvalue ;
10481 bool result;
10482 void *argp1 = 0 ;
10483 int res1 = 0 ;
10484 void *argp2 = 0 ;
10485 int res2 = 0 ;
10486 int val3 ;
10487 int ecode3 = 0 ;
10488 wxPoint temp4 ;
10489 wxSize temp5 ;
10490 long val6 ;
10491 int ecode6 = 0 ;
10492 bool temp7 = false ;
10493 PyObject * obj0 = 0 ;
10494 PyObject * obj1 = 0 ;
10495 PyObject * obj2 = 0 ;
10496 PyObject * obj3 = 0 ;
10497 PyObject * obj4 = 0 ;
10498 PyObject * obj5 = 0 ;
10499 PyObject * obj6 = 0 ;
10500 char * kwnames[] = {
10501 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10502 };
10503
10504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10508 }
10509 arg1 = reinterpret_cast< wxGrid * >(argp1);
10510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10511 if (!SWIG_IsOK(res2)) {
10512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10513 }
10514 arg2 = reinterpret_cast< wxWindow * >(argp2);
10515 if (obj2) {
10516 ecode3 = SWIG_AsVal_int(obj2, &val3);
10517 if (!SWIG_IsOK(ecode3)) {
10518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10519 }
10520 arg3 = static_cast< int >(val3);
10521 }
10522 if (obj3) {
10523 {
10524 arg4 = &temp4;
10525 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10526 }
10527 }
10528 if (obj4) {
10529 {
10530 arg5 = &temp5;
10531 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10532 }
10533 }
10534 if (obj5) {
10535 ecode6 = SWIG_AsVal_long(obj5, &val6);
10536 if (!SWIG_IsOK(ecode6)) {
10537 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10538 }
10539 arg6 = static_cast< long >(val6);
10540 }
10541 if (obj6) {
10542 {
10543 arg7 = wxString_in_helper(obj6);
10544 if (arg7 == NULL) SWIG_fail;
10545 temp7 = true;
10546 }
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 {
10555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10556 }
10557 {
10558 if (temp7)
10559 delete arg7;
10560 }
10561 return resultobj;
10562 fail:
10563 {
10564 if (temp7)
10565 delete arg7;
10566 }
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj = 0;
10573 wxGrid *arg1 = (wxGrid *) 0 ;
10574 int arg2 ;
10575 int arg3 ;
10576 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10577 bool result;
10578 void *argp1 = 0 ;
10579 int res1 = 0 ;
10580 int val2 ;
10581 int ecode2 = 0 ;
10582 int val3 ;
10583 int ecode3 = 0 ;
10584 int val4 ;
10585 int ecode4 = 0 ;
10586 PyObject * obj0 = 0 ;
10587 PyObject * obj1 = 0 ;
10588 PyObject * obj2 = 0 ;
10589 PyObject * obj3 = 0 ;
10590 char * kwnames[] = {
10591 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10592 };
10593
10594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10596 if (!SWIG_IsOK(res1)) {
10597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10598 }
10599 arg1 = reinterpret_cast< wxGrid * >(argp1);
10600 ecode2 = SWIG_AsVal_int(obj1, &val2);
10601 if (!SWIG_IsOK(ecode2)) {
10602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10603 }
10604 arg2 = static_cast< int >(val2);
10605 ecode3 = SWIG_AsVal_int(obj2, &val3);
10606 if (!SWIG_IsOK(ecode3)) {
10607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10608 }
10609 arg3 = static_cast< int >(val3);
10610 if (obj3) {
10611 ecode4 = SWIG_AsVal_int(obj3, &val4);
10612 if (!SWIG_IsOK(ecode4)) {
10613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10614 }
10615 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10616 }
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 {
10624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10625 }
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj = 0;
10634 wxGrid *arg1 = (wxGrid *) 0 ;
10635 WXGRIDSELECTIONMODES arg2 ;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 int val2 ;
10639 int ecode2 = 0 ;
10640 PyObject * obj0 = 0 ;
10641 PyObject * obj1 = 0 ;
10642 char * kwnames[] = {
10643 (char *) "self",(char *) "selmode", NULL
10644 };
10645
10646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10648 if (!SWIG_IsOK(res1)) {
10649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10650 }
10651 arg1 = reinterpret_cast< wxGrid * >(argp1);
10652 ecode2 = SWIG_AsVal_int(obj1, &val2);
10653 if (!SWIG_IsOK(ecode2)) {
10654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10655 }
10656 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 (arg1)->SetSelectionMode(arg2);
10660 wxPyEndAllowThreads(__tstate);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 resultobj = SWIG_Py_Void();
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10671 PyObject *resultobj = 0;
10672 wxGrid *arg1 = (wxGrid *) 0 ;
10673 WXGRIDSELECTIONMODES result;
10674 void *argp1 = 0 ;
10675 int res1 = 0 ;
10676 PyObject *swig_obj[1] ;
10677
10678 if (!args) SWIG_fail;
10679 swig_obj[0] = args;
10680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10681 if (!SWIG_IsOK(res1)) {
10682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10683 }
10684 arg1 = reinterpret_cast< wxGrid * >(argp1);
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_From_int(static_cast< int >(result));
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699 PyObject *resultobj = 0;
10700 wxGrid *arg1 = (wxGrid *) 0 ;
10701 int result;
10702 void *argp1 = 0 ;
10703 int res1 = 0 ;
10704 PyObject *swig_obj[1] ;
10705
10706 if (!args) SWIG_fail;
10707 swig_obj[0] = args;
10708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10711 }
10712 arg1 = reinterpret_cast< wxGrid * >(argp1);
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = (int)(arg1)->GetNumberRows();
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 resultobj = SWIG_From_int(static_cast< int >(result));
10720 return resultobj;
10721 fail:
10722 return NULL;
10723 }
10724
10725
10726 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10727 PyObject *resultobj = 0;
10728 wxGrid *arg1 = (wxGrid *) 0 ;
10729 int result;
10730 void *argp1 = 0 ;
10731 int res1 = 0 ;
10732 PyObject *swig_obj[1] ;
10733
10734 if (!args) SWIG_fail;
10735 swig_obj[0] = args;
10736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10737 if (!SWIG_IsOK(res1)) {
10738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10739 }
10740 arg1 = reinterpret_cast< wxGrid * >(argp1);
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (int)(arg1)->GetNumberCols();
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 resultobj = SWIG_From_int(static_cast< int >(result));
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj = 0;
10756 wxGrid *arg1 = (wxGrid *) 0 ;
10757 wxGridTableMessage *arg2 = 0 ;
10758 bool result;
10759 void *argp1 = 0 ;
10760 int res1 = 0 ;
10761 void *argp2 = 0 ;
10762 int res2 = 0 ;
10763 PyObject * obj0 = 0 ;
10764 PyObject * obj1 = 0 ;
10765 char * kwnames[] = {
10766 (char *) "self",(char *)"arg2", NULL
10767 };
10768
10769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10771 if (!SWIG_IsOK(res1)) {
10772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10773 }
10774 arg1 = reinterpret_cast< wxGrid * >(argp1);
10775 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10776 if (!SWIG_IsOK(res2)) {
10777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10778 }
10779 if (!argp2) {
10780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10781 }
10782 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 {
10790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10791 }
10792 return resultobj;
10793 fail:
10794 return NULL;
10795 }
10796
10797
10798 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10799 PyObject *resultobj = 0;
10800 wxGrid *arg1 = (wxGrid *) 0 ;
10801 wxGridTableBase *result = 0 ;
10802 void *argp1 = 0 ;
10803 int res1 = 0 ;
10804 PyObject *swig_obj[1] ;
10805
10806 if (!args) SWIG_fail;
10807 swig_obj[0] = args;
10808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10809 if (!SWIG_IsOK(res1)) {
10810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10811 }
10812 arg1 = reinterpret_cast< wxGrid * >(argp1);
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10821 }
10822 return resultobj;
10823 fail:
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10829 PyObject *resultobj = 0;
10830 wxGrid *arg1 = (wxGrid *) 0 ;
10831 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10832 bool arg3 = (bool) false ;
10833 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10834 bool result;
10835 void *argp1 = 0 ;
10836 int res1 = 0 ;
10837 int res2 = 0 ;
10838 bool val3 ;
10839 int ecode3 = 0 ;
10840 int val4 ;
10841 int ecode4 = 0 ;
10842 PyObject * obj0 = 0 ;
10843 PyObject * obj1 = 0 ;
10844 PyObject * obj2 = 0 ;
10845 PyObject * obj3 = 0 ;
10846 char * kwnames[] = {
10847 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10848 };
10849
10850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10852 if (!SWIG_IsOK(res1)) {
10853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10854 }
10855 arg1 = reinterpret_cast< wxGrid * >(argp1);
10856 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10857 if (!SWIG_IsOK(res2)) {
10858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
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_SetTable" "', expected argument " "3"" of type '" "bool""'");
10864 }
10865 arg3 = static_cast< bool >(val3);
10866 }
10867 if (obj3) {
10868 ecode4 = SWIG_AsVal_int(obj3, &val4);
10869 if (!SWIG_IsOK(ecode4)) {
10870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10871 }
10872 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10873 }
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10877 wxPyEndAllowThreads(__tstate);
10878 if (PyErr_Occurred()) SWIG_fail;
10879 }
10880 {
10881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891 wxGrid *arg1 = (wxGrid *) 0 ;
10892 void *argp1 = 0 ;
10893 int res1 = 0 ;
10894 PyObject *swig_obj[1] ;
10895
10896 if (!args) SWIG_fail;
10897 swig_obj[0] = args;
10898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10899 if (!SWIG_IsOK(res1)) {
10900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10901 }
10902 arg1 = reinterpret_cast< wxGrid * >(argp1);
10903 {
10904 PyThreadState* __tstate = wxPyBeginAllowThreads();
10905 (arg1)->ClearGrid();
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 resultobj = SWIG_Py_Void();
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10917 PyObject *resultobj = 0;
10918 wxGrid *arg1 = (wxGrid *) 0 ;
10919 int arg2 = (int) 0 ;
10920 int arg3 = (int) 1 ;
10921 bool arg4 = (bool) true ;
10922 bool result;
10923 void *argp1 = 0 ;
10924 int res1 = 0 ;
10925 int val2 ;
10926 int ecode2 = 0 ;
10927 int val3 ;
10928 int ecode3 = 0 ;
10929 bool val4 ;
10930 int ecode4 = 0 ;
10931 PyObject * obj0 = 0 ;
10932 PyObject * obj1 = 0 ;
10933 PyObject * obj2 = 0 ;
10934 PyObject * obj3 = 0 ;
10935 char * kwnames[] = {
10936 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10937 };
10938
10939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10941 if (!SWIG_IsOK(res1)) {
10942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10943 }
10944 arg1 = reinterpret_cast< wxGrid * >(argp1);
10945 if (obj1) {
10946 ecode2 = SWIG_AsVal_int(obj1, &val2);
10947 if (!SWIG_IsOK(ecode2)) {
10948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10949 }
10950 arg2 = static_cast< int >(val2);
10951 }
10952 if (obj2) {
10953 ecode3 = SWIG_AsVal_int(obj2, &val3);
10954 if (!SWIG_IsOK(ecode3)) {
10955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10956 }
10957 arg3 = static_cast< int >(val3);
10958 }
10959 if (obj3) {
10960 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10961 if (!SWIG_IsOK(ecode4)) {
10962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10963 }
10964 arg4 = static_cast< bool >(val4);
10965 }
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10969 wxPyEndAllowThreads(__tstate);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 {
10973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj = 0;
10983 wxGrid *arg1 = (wxGrid *) 0 ;
10984 int arg2 = (int) 1 ;
10985 bool arg3 = (bool) true ;
10986 bool result;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 int val2 ;
10990 int ecode2 = 0 ;
10991 bool val3 ;
10992 int ecode3 = 0 ;
10993 PyObject * obj0 = 0 ;
10994 PyObject * obj1 = 0 ;
10995 PyObject * obj2 = 0 ;
10996 char * kwnames[] = {
10997 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10998 };
10999
11000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11002 if (!SWIG_IsOK(res1)) {
11003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11004 }
11005 arg1 = reinterpret_cast< wxGrid * >(argp1);
11006 if (obj1) {
11007 ecode2 = SWIG_AsVal_int(obj1, &val2);
11008 if (!SWIG_IsOK(ecode2)) {
11009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11010 }
11011 arg2 = static_cast< int >(val2);
11012 }
11013 if (obj2) {
11014 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11015 if (!SWIG_IsOK(ecode3)) {
11016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11017 }
11018 arg3 = static_cast< bool >(val3);
11019 }
11020 {
11021 PyThreadState* __tstate = wxPyBeginAllowThreads();
11022 result = (bool)(arg1)->AppendRows(arg2,arg3);
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 {
11027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11028 }
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11036 PyObject *resultobj = 0;
11037 wxGrid *arg1 = (wxGrid *) 0 ;
11038 int arg2 = (int) 0 ;
11039 int arg3 = (int) 1 ;
11040 bool arg4 = (bool) true ;
11041 bool result;
11042 void *argp1 = 0 ;
11043 int res1 = 0 ;
11044 int val2 ;
11045 int ecode2 = 0 ;
11046 int val3 ;
11047 int ecode3 = 0 ;
11048 bool val4 ;
11049 int ecode4 = 0 ;
11050 PyObject * obj0 = 0 ;
11051 PyObject * obj1 = 0 ;
11052 PyObject * obj2 = 0 ;
11053 PyObject * obj3 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11060 if (!SWIG_IsOK(res1)) {
11061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11062 }
11063 arg1 = reinterpret_cast< wxGrid * >(argp1);
11064 if (obj1) {
11065 ecode2 = SWIG_AsVal_int(obj1, &val2);
11066 if (!SWIG_IsOK(ecode2)) {
11067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11068 }
11069 arg2 = static_cast< int >(val2);
11070 }
11071 if (obj2) {
11072 ecode3 = SWIG_AsVal_int(obj2, &val3);
11073 if (!SWIG_IsOK(ecode3)) {
11074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11075 }
11076 arg3 = static_cast< int >(val3);
11077 }
11078 if (obj3) {
11079 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11080 if (!SWIG_IsOK(ecode4)) {
11081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11082 }
11083 arg4 = static_cast< bool >(val4);
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 {
11092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11093 }
11094 return resultobj;
11095 fail:
11096 return NULL;
11097 }
11098
11099
11100 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj = 0;
11102 wxGrid *arg1 = (wxGrid *) 0 ;
11103 int arg2 = (int) 0 ;
11104 int arg3 = (int) 1 ;
11105 bool arg4 = (bool) true ;
11106 bool result;
11107 void *argp1 = 0 ;
11108 int res1 = 0 ;
11109 int val2 ;
11110 int ecode2 = 0 ;
11111 int val3 ;
11112 int ecode3 = 0 ;
11113 bool val4 ;
11114 int ecode4 = 0 ;
11115 PyObject * obj0 = 0 ;
11116 PyObject * obj1 = 0 ;
11117 PyObject * obj2 = 0 ;
11118 PyObject * obj3 = 0 ;
11119 char * kwnames[] = {
11120 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11121 };
11122
11123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11125 if (!SWIG_IsOK(res1)) {
11126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11127 }
11128 arg1 = reinterpret_cast< wxGrid * >(argp1);
11129 if (obj1) {
11130 ecode2 = SWIG_AsVal_int(obj1, &val2);
11131 if (!SWIG_IsOK(ecode2)) {
11132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11133 }
11134 arg2 = static_cast< int >(val2);
11135 }
11136 if (obj2) {
11137 ecode3 = SWIG_AsVal_int(obj2, &val3);
11138 if (!SWIG_IsOK(ecode3)) {
11139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11140 }
11141 arg3 = static_cast< int >(val3);
11142 }
11143 if (obj3) {
11144 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11145 if (!SWIG_IsOK(ecode4)) {
11146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11147 }
11148 arg4 = static_cast< bool >(val4);
11149 }
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11153 wxPyEndAllowThreads(__tstate);
11154 if (PyErr_Occurred()) SWIG_fail;
11155 }
11156 {
11157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11158 }
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj = 0;
11167 wxGrid *arg1 = (wxGrid *) 0 ;
11168 int arg2 = (int) 1 ;
11169 bool arg3 = (bool) true ;
11170 bool result;
11171 void *argp1 = 0 ;
11172 int res1 = 0 ;
11173 int val2 ;
11174 int ecode2 = 0 ;
11175 bool val3 ;
11176 int ecode3 = 0 ;
11177 PyObject * obj0 = 0 ;
11178 PyObject * obj1 = 0 ;
11179 PyObject * obj2 = 0 ;
11180 char * kwnames[] = {
11181 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11182 };
11183
11184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11186 if (!SWIG_IsOK(res1)) {
11187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11188 }
11189 arg1 = reinterpret_cast< wxGrid * >(argp1);
11190 if (obj1) {
11191 ecode2 = SWIG_AsVal_int(obj1, &val2);
11192 if (!SWIG_IsOK(ecode2)) {
11193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11194 }
11195 arg2 = static_cast< int >(val2);
11196 }
11197 if (obj2) {
11198 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11199 if (!SWIG_IsOK(ecode3)) {
11200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11201 }
11202 arg3 = static_cast< bool >(val3);
11203 }
11204 {
11205 PyThreadState* __tstate = wxPyBeginAllowThreads();
11206 result = (bool)(arg1)->AppendCols(arg2,arg3);
11207 wxPyEndAllowThreads(__tstate);
11208 if (PyErr_Occurred()) SWIG_fail;
11209 }
11210 {
11211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11212 }
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11220 PyObject *resultobj = 0;
11221 wxGrid *arg1 = (wxGrid *) 0 ;
11222 int arg2 = (int) 0 ;
11223 int arg3 = (int) 1 ;
11224 bool arg4 = (bool) true ;
11225 bool result;
11226 void *argp1 = 0 ;
11227 int res1 = 0 ;
11228 int val2 ;
11229 int ecode2 = 0 ;
11230 int val3 ;
11231 int ecode3 = 0 ;
11232 bool val4 ;
11233 int ecode4 = 0 ;
11234 PyObject * obj0 = 0 ;
11235 PyObject * obj1 = 0 ;
11236 PyObject * obj2 = 0 ;
11237 PyObject * obj3 = 0 ;
11238 char * kwnames[] = {
11239 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11240 };
11241
11242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11244 if (!SWIG_IsOK(res1)) {
11245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11246 }
11247 arg1 = reinterpret_cast< wxGrid * >(argp1);
11248 if (obj1) {
11249 ecode2 = SWIG_AsVal_int(obj1, &val2);
11250 if (!SWIG_IsOK(ecode2)) {
11251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11252 }
11253 arg2 = static_cast< int >(val2);
11254 }
11255 if (obj2) {
11256 ecode3 = SWIG_AsVal_int(obj2, &val3);
11257 if (!SWIG_IsOK(ecode3)) {
11258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11259 }
11260 arg3 = static_cast< int >(val3);
11261 }
11262 if (obj3) {
11263 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11264 if (!SWIG_IsOK(ecode4)) {
11265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11266 }
11267 arg4 = static_cast< bool >(val4);
11268 }
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 {
11276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11277 }
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj = 0;
11286 wxGrid *arg1 = (wxGrid *) 0 ;
11287 wxDC *arg2 = 0 ;
11288 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11289 void *argp1 = 0 ;
11290 int res1 = 0 ;
11291 void *argp2 = 0 ;
11292 int res2 = 0 ;
11293 void *argp3 = 0 ;
11294 int res3 = 0 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 char * kwnames[] = {
11299 (char *) "self",(char *) "dc",(char *) "attr", NULL
11300 };
11301
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11304 if (!SWIG_IsOK(res1)) {
11305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11306 }
11307 arg1 = reinterpret_cast< wxGrid * >(argp1);
11308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11309 if (!SWIG_IsOK(res2)) {
11310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11311 }
11312 if (!argp2) {
11313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11314 }
11315 arg2 = reinterpret_cast< wxDC * >(argp2);
11316 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11317 if (!SWIG_IsOK(res3)) {
11318 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11319 }
11320 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11321 {
11322 PyThreadState* __tstate = wxPyBeginAllowThreads();
11323 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 resultobj = SWIG_Py_Void();
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj = 0;
11336 wxGrid *arg1 = (wxGrid *) 0 ;
11337 wxDC *arg2 = 0 ;
11338 wxString *arg3 = 0 ;
11339 wxRect *arg4 = 0 ;
11340 int arg5 = (int) wxLEFT ;
11341 int arg6 = (int) wxTOP ;
11342 int arg7 = (int) wxHORIZONTAL ;
11343 void *argp1 = 0 ;
11344 int res1 = 0 ;
11345 void *argp2 = 0 ;
11346 int res2 = 0 ;
11347 bool temp3 = false ;
11348 wxRect temp4 ;
11349 int val5 ;
11350 int ecode5 = 0 ;
11351 int val6 ;
11352 int ecode6 = 0 ;
11353 int val7 ;
11354 int ecode7 = 0 ;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 PyObject * obj2 = 0 ;
11358 PyObject * obj3 = 0 ;
11359 PyObject * obj4 = 0 ;
11360 PyObject * obj5 = 0 ;
11361 PyObject * obj6 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11368 if (!SWIG_IsOK(res1)) {
11369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11370 }
11371 arg1 = reinterpret_cast< wxGrid * >(argp1);
11372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11373 if (!SWIG_IsOK(res2)) {
11374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11375 }
11376 if (!argp2) {
11377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11378 }
11379 arg2 = reinterpret_cast< wxDC * >(argp2);
11380 {
11381 arg3 = wxString_in_helper(obj2);
11382 if (arg3 == NULL) SWIG_fail;
11383 temp3 = true;
11384 }
11385 {
11386 arg4 = &temp4;
11387 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11388 }
11389 if (obj4) {
11390 ecode5 = SWIG_AsVal_int(obj4, &val5);
11391 if (!SWIG_IsOK(ecode5)) {
11392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11393 }
11394 arg5 = static_cast< int >(val5);
11395 }
11396 if (obj5) {
11397 ecode6 = SWIG_AsVal_int(obj5, &val6);
11398 if (!SWIG_IsOK(ecode6)) {
11399 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11400 }
11401 arg6 = static_cast< int >(val6);
11402 }
11403 if (obj6) {
11404 ecode7 = SWIG_AsVal_int(obj6, &val7);
11405 if (!SWIG_IsOK(ecode7)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11407 }
11408 arg7 = static_cast< int >(val7);
11409 }
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 {
11418 if (temp3)
11419 delete arg3;
11420 }
11421 return resultobj;
11422 fail:
11423 {
11424 if (temp3)
11425 delete arg3;
11426 }
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxGrid *arg1 = (wxGrid *) 0 ;
11434 wxDC *arg2 = 0 ;
11435 wxArrayString *arg3 = 0 ;
11436 long *arg4 = (long *) 0 ;
11437 long *arg5 = (long *) 0 ;
11438 void *argp1 = 0 ;
11439 int res1 = 0 ;
11440 void *argp2 = 0 ;
11441 int res2 = 0 ;
11442 bool temp3 = false ;
11443 long temp4 ;
11444 int res4 = SWIG_TMPOBJ ;
11445 long temp5 ;
11446 int res5 = SWIG_TMPOBJ ;
11447 PyObject * obj0 = 0 ;
11448 PyObject * obj1 = 0 ;
11449 PyObject * obj2 = 0 ;
11450 char * kwnames[] = {
11451 (char *) "self",(char *) "dc",(char *) "lines", NULL
11452 };
11453
11454 arg4 = &temp4;
11455 arg5 = &temp5;
11456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11458 if (!SWIG_IsOK(res1)) {
11459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11460 }
11461 arg1 = reinterpret_cast< wxGrid * >(argp1);
11462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11463 if (!SWIG_IsOK(res2)) {
11464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11465 }
11466 if (!argp2) {
11467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11468 }
11469 arg2 = reinterpret_cast< wxDC * >(argp2);
11470 {
11471 if (! PySequence_Check(obj2)) {
11472 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11473 SWIG_fail;
11474 }
11475 arg3 = new wxArrayString;
11476 temp3 = true;
11477 int i, len=PySequence_Length(obj2);
11478 for (i=0; i<len; i++) {
11479 PyObject* item = PySequence_GetItem(obj2, i);
11480 wxString* s = wxString_in_helper(item);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 arg3->Add(*s);
11483 delete s;
11484 Py_DECREF(item);
11485 }
11486 }
11487 {
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 resultobj = SWIG_Py_Void();
11494 if (SWIG_IsTmpObj(res4)) {
11495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11496 } else {
11497 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11499 }
11500 if (SWIG_IsTmpObj(res5)) {
11501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11502 } else {
11503 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11505 }
11506 {
11507 if (temp3) delete arg3;
11508 }
11509 return resultobj;
11510 fail:
11511 {
11512 if (temp3) delete arg3;
11513 }
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11519 PyObject *resultobj = 0;
11520 wxGrid *arg1 = (wxGrid *) 0 ;
11521 void *argp1 = 0 ;
11522 int res1 = 0 ;
11523 PyObject *swig_obj[1] ;
11524
11525 if (!args) SWIG_fail;
11526 swig_obj[0] = args;
11527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11528 if (!SWIG_IsOK(res1)) {
11529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11530 }
11531 arg1 = reinterpret_cast< wxGrid * >(argp1);
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 (arg1)->BeginBatch();
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_Py_Void();
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11546 PyObject *resultobj = 0;
11547 wxGrid *arg1 = (wxGrid *) 0 ;
11548 void *argp1 = 0 ;
11549 int res1 = 0 ;
11550 PyObject *swig_obj[1] ;
11551
11552 if (!args) SWIG_fail;
11553 swig_obj[0] = args;
11554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11555 if (!SWIG_IsOK(res1)) {
11556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11557 }
11558 arg1 = reinterpret_cast< wxGrid * >(argp1);
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 (arg1)->EndBatch();
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_Py_Void();
11566 return resultobj;
11567 fail:
11568 return NULL;
11569 }
11570
11571
11572 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 wxGrid *arg1 = (wxGrid *) 0 ;
11575 int result;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 PyObject *swig_obj[1] ;
11579
11580 if (!args) SWIG_fail;
11581 swig_obj[0] = args;
11582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11585 }
11586 arg1 = reinterpret_cast< wxGrid * >(argp1);
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (int)(arg1)->GetBatchCount();
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 resultobj = SWIG_From_int(static_cast< int >(result));
11594 return resultobj;
11595 fail:
11596 return NULL;
11597 }
11598
11599
11600 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11601 PyObject *resultobj = 0;
11602 wxGrid *arg1 = (wxGrid *) 0 ;
11603 void *argp1 = 0 ;
11604 int res1 = 0 ;
11605 PyObject *swig_obj[1] ;
11606
11607 if (!args) SWIG_fail;
11608 swig_obj[0] = args;
11609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11610 if (!SWIG_IsOK(res1)) {
11611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11612 }
11613 arg1 = reinterpret_cast< wxGrid * >(argp1);
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 (arg1)->ForceRefresh();
11617 wxPyEndAllowThreads(__tstate);
11618 if (PyErr_Occurred()) SWIG_fail;
11619 }
11620 resultobj = SWIG_Py_Void();
11621 return resultobj;
11622 fail:
11623 return NULL;
11624 }
11625
11626
11627 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11628 PyObject *resultobj = 0;
11629 wxGrid *arg1 = (wxGrid *) 0 ;
11630 bool result;
11631 void *argp1 = 0 ;
11632 int res1 = 0 ;
11633 PyObject *swig_obj[1] ;
11634
11635 if (!args) SWIG_fail;
11636 swig_obj[0] = args;
11637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11638 if (!SWIG_IsOK(res1)) {
11639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11640 }
11641 arg1 = reinterpret_cast< wxGrid * >(argp1);
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (bool)(arg1)->IsEditable();
11645 wxPyEndAllowThreads(__tstate);
11646 if (PyErr_Occurred()) SWIG_fail;
11647 }
11648 {
11649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11650 }
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj = 0;
11659 wxGrid *arg1 = (wxGrid *) 0 ;
11660 bool arg2 ;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 bool val2 ;
11664 int ecode2 = 0 ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 char * kwnames[] = {
11668 (char *) "self",(char *) "edit", NULL
11669 };
11670
11671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11673 if (!SWIG_IsOK(res1)) {
11674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11675 }
11676 arg1 = reinterpret_cast< wxGrid * >(argp1);
11677 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11678 if (!SWIG_IsOK(ecode2)) {
11679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11680 }
11681 arg2 = static_cast< bool >(val2);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 (arg1)->EnableEditing(arg2);
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_Py_Void();
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11696 PyObject *resultobj = 0;
11697 wxGrid *arg1 = (wxGrid *) 0 ;
11698 bool arg2 = (bool) true ;
11699 void *argp1 = 0 ;
11700 int res1 = 0 ;
11701 bool val2 ;
11702 int ecode2 = 0 ;
11703 PyObject * obj0 = 0 ;
11704 PyObject * obj1 = 0 ;
11705 char * kwnames[] = {
11706 (char *) "self",(char *) "enable", NULL
11707 };
11708
11709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11711 if (!SWIG_IsOK(res1)) {
11712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11713 }
11714 arg1 = reinterpret_cast< wxGrid * >(argp1);
11715 if (obj1) {
11716 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11717 if (!SWIG_IsOK(ecode2)) {
11718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11719 }
11720 arg2 = static_cast< bool >(val2);
11721 }
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 (arg1)->EnableCellEditControl(arg2);
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 resultobj = SWIG_Py_Void();
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxGrid *arg1 = (wxGrid *) 0 ;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11747 }
11748 arg1 = reinterpret_cast< wxGrid * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 (arg1)->DisableCellEditControl();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_Py_Void();
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxGrid *arg1 = (wxGrid *) 0 ;
11765 bool result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11775 }
11776 arg1 = reinterpret_cast< wxGrid * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 {
11784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 PyObject *resultobj = 0;
11794 wxGrid *arg1 = (wxGrid *) 0 ;
11795 bool result;
11796 void *argp1 = 0 ;
11797 int res1 = 0 ;
11798 PyObject *swig_obj[1] ;
11799
11800 if (!args) SWIG_fail;
11801 swig_obj[0] = args;
11802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11803 if (!SWIG_IsOK(res1)) {
11804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11805 }
11806 arg1 = reinterpret_cast< wxGrid * >(argp1);
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 {
11814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11815 }
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11823 PyObject *resultobj = 0;
11824 wxGrid *arg1 = (wxGrid *) 0 ;
11825 bool result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 PyObject *swig_obj[1] ;
11829
11830 if (!args) SWIG_fail;
11831 swig_obj[0] = args;
11832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11835 }
11836 arg1 = reinterpret_cast< wxGrid * >(argp1);
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11845 }
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11853 PyObject *resultobj = 0;
11854 wxGrid *arg1 = (wxGrid *) 0 ;
11855 bool result;
11856 void *argp1 = 0 ;
11857 int res1 = 0 ;
11858 PyObject *swig_obj[1] ;
11859
11860 if (!args) SWIG_fail;
11861 swig_obj[0] = args;
11862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11863 if (!SWIG_IsOK(res1)) {
11864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11865 }
11866 arg1 = reinterpret_cast< wxGrid * >(argp1);
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 {
11874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11875 }
11876 return resultobj;
11877 fail:
11878 return NULL;
11879 }
11880
11881
11882 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11883 PyObject *resultobj = 0;
11884 wxGrid *arg1 = (wxGrid *) 0 ;
11885 void *argp1 = 0 ;
11886 int res1 = 0 ;
11887 PyObject *swig_obj[1] ;
11888
11889 if (!args) SWIG_fail;
11890 swig_obj[0] = args;
11891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11892 if (!SWIG_IsOK(res1)) {
11893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11894 }
11895 arg1 = reinterpret_cast< wxGrid * >(argp1);
11896 {
11897 PyThreadState* __tstate = wxPyBeginAllowThreads();
11898 (arg1)->ShowCellEditControl();
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 resultobj = SWIG_Py_Void();
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910 PyObject *resultobj = 0;
11911 wxGrid *arg1 = (wxGrid *) 0 ;
11912 void *argp1 = 0 ;
11913 int res1 = 0 ;
11914 PyObject *swig_obj[1] ;
11915
11916 if (!args) SWIG_fail;
11917 swig_obj[0] = args;
11918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11921 }
11922 arg1 = reinterpret_cast< wxGrid * >(argp1);
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 (arg1)->HideCellEditControl();
11926 wxPyEndAllowThreads(__tstate);
11927 if (PyErr_Occurred()) SWIG_fail;
11928 }
11929 resultobj = SWIG_Py_Void();
11930 return resultobj;
11931 fail:
11932 return NULL;
11933 }
11934
11935
11936 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11937 PyObject *resultobj = 0;
11938 wxGrid *arg1 = (wxGrid *) 0 ;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 PyObject *swig_obj[1] ;
11942
11943 if (!args) SWIG_fail;
11944 swig_obj[0] = args;
11945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11948 }
11949 arg1 = reinterpret_cast< wxGrid * >(argp1);
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 (arg1)->SaveEditControlValue();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 resultobj = SWIG_Py_Void();
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj = 0;
11965 wxGrid *arg1 = (wxGrid *) 0 ;
11966 int arg2 ;
11967 int arg3 ;
11968 wxGridCellCoords result;
11969 void *argp1 = 0 ;
11970 int res1 = 0 ;
11971 int val2 ;
11972 int ecode2 = 0 ;
11973 int val3 ;
11974 int ecode3 = 0 ;
11975 PyObject * obj0 = 0 ;
11976 PyObject * obj1 = 0 ;
11977 PyObject * obj2 = 0 ;
11978 char * kwnames[] = {
11979 (char *) "self",(char *) "x",(char *) "y", NULL
11980 };
11981
11982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11984 if (!SWIG_IsOK(res1)) {
11985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11986 }
11987 arg1 = reinterpret_cast< wxGrid * >(argp1);
11988 ecode2 = SWIG_AsVal_int(obj1, &val2);
11989 if (!SWIG_IsOK(ecode2)) {
11990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11991 }
11992 arg2 = static_cast< int >(val2);
11993 ecode3 = SWIG_AsVal_int(obj2, &val3);
11994 if (!SWIG_IsOK(ecode3)) {
11995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11996 }
11997 arg3 = static_cast< int >(val3);
11998 {
11999 PyThreadState* __tstate = wxPyBeginAllowThreads();
12000 result = wxGrid_XYToCell(arg1,arg2,arg3);
12001 wxPyEndAllowThreads(__tstate);
12002 if (PyErr_Occurred()) SWIG_fail;
12003 }
12004 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj = 0;
12013 wxGrid *arg1 = (wxGrid *) 0 ;
12014 int arg2 ;
12015 int result;
12016 void *argp1 = 0 ;
12017 int res1 = 0 ;
12018 int val2 ;
12019 int ecode2 = 0 ;
12020 PyObject * obj0 = 0 ;
12021 PyObject * obj1 = 0 ;
12022 char * kwnames[] = {
12023 (char *) "self",(char *) "y", NULL
12024 };
12025
12026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12028 if (!SWIG_IsOK(res1)) {
12029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12030 }
12031 arg1 = reinterpret_cast< wxGrid * >(argp1);
12032 ecode2 = SWIG_AsVal_int(obj1, &val2);
12033 if (!SWIG_IsOK(ecode2)) {
12034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12035 }
12036 arg2 = static_cast< int >(val2);
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (int)(arg1)->YToRow(arg2);
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 resultobj = SWIG_From_int(static_cast< int >(result));
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj = 0;
12052 wxGrid *arg1 = (wxGrid *) 0 ;
12053 int arg2 ;
12054 bool arg3 = (bool) false ;
12055 int result;
12056 void *argp1 = 0 ;
12057 int res1 = 0 ;
12058 int val2 ;
12059 int ecode2 = 0 ;
12060 bool val3 ;
12061 int ecode3 = 0 ;
12062 PyObject * obj0 = 0 ;
12063 PyObject * obj1 = 0 ;
12064 PyObject * obj2 = 0 ;
12065 char * kwnames[] = {
12066 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12067 };
12068
12069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12073 }
12074 arg1 = reinterpret_cast< wxGrid * >(argp1);
12075 ecode2 = SWIG_AsVal_int(obj1, &val2);
12076 if (!SWIG_IsOK(ecode2)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12078 }
12079 arg2 = static_cast< int >(val2);
12080 if (obj2) {
12081 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12082 if (!SWIG_IsOK(ecode3)) {
12083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12084 }
12085 arg3 = static_cast< bool >(val3);
12086 }
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (int)(arg1)->XToCol(arg2,arg3);
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_int(static_cast< int >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj = 0;
12102 wxGrid *arg1 = (wxGrid *) 0 ;
12103 int arg2 ;
12104 int result;
12105 void *argp1 = 0 ;
12106 int res1 = 0 ;
12107 int val2 ;
12108 int ecode2 = 0 ;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12111 char * kwnames[] = {
12112 (char *) "self",(char *) "y", NULL
12113 };
12114
12115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12119 }
12120 arg1 = reinterpret_cast< wxGrid * >(argp1);
12121 ecode2 = SWIG_AsVal_int(obj1, &val2);
12122 if (!SWIG_IsOK(ecode2)) {
12123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12124 }
12125 arg2 = static_cast< int >(val2);
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = (int)(arg1)->YToEdgeOfRow(arg2);
12129 wxPyEndAllowThreads(__tstate);
12130 if (PyErr_Occurred()) SWIG_fail;
12131 }
12132 resultobj = SWIG_From_int(static_cast< int >(result));
12133 return resultobj;
12134 fail:
12135 return NULL;
12136 }
12137
12138
12139 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12140 PyObject *resultobj = 0;
12141 wxGrid *arg1 = (wxGrid *) 0 ;
12142 int arg2 ;
12143 int result;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 int val2 ;
12147 int ecode2 = 0 ;
12148 PyObject * obj0 = 0 ;
12149 PyObject * obj1 = 0 ;
12150 char * kwnames[] = {
12151 (char *) "self",(char *) "x", NULL
12152 };
12153
12154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12156 if (!SWIG_IsOK(res1)) {
12157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12158 }
12159 arg1 = reinterpret_cast< wxGrid * >(argp1);
12160 ecode2 = SWIG_AsVal_int(obj1, &val2);
12161 if (!SWIG_IsOK(ecode2)) {
12162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12163 }
12164 arg2 = static_cast< int >(val2);
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (int)(arg1)->XToEdgeOfCol(arg2);
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 resultobj = SWIG_From_int(static_cast< int >(result));
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxGrid *arg1 = (wxGrid *) 0 ;
12181 int arg2 ;
12182 int arg3 ;
12183 wxRect result;
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_CellToRect",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_CellToRect" "', 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_CellToRect" "', 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_CellToRect" "', expected argument " "3"" of type '" "int""'");
12211 }
12212 arg3 = static_cast< int >(val3);
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 result = (arg1)->CellToRect(arg2,arg3);
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12227 PyObject *resultobj = 0;
12228 wxGrid *arg1 = (wxGrid *) 0 ;
12229 int result;
12230 void *argp1 = 0 ;
12231 int res1 = 0 ;
12232 PyObject *swig_obj[1] ;
12233
12234 if (!args) SWIG_fail;
12235 swig_obj[0] = args;
12236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12237 if (!SWIG_IsOK(res1)) {
12238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12239 }
12240 arg1 = reinterpret_cast< wxGrid * >(argp1);
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (int)(arg1)->GetGridCursorRow();
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 resultobj = SWIG_From_int(static_cast< int >(result));
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12255 PyObject *resultobj = 0;
12256 wxGrid *arg1 = (wxGrid *) 0 ;
12257 int result;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 PyObject *swig_obj[1] ;
12261
12262 if (!args) SWIG_fail;
12263 swig_obj[0] = args;
12264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12267 }
12268 arg1 = reinterpret_cast< wxGrid * >(argp1);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 result = (int)(arg1)->GetGridCursorCol();
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_From_int(static_cast< int >(result));
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj = 0;
12284 wxGrid *arg1 = (wxGrid *) 0 ;
12285 int arg2 ;
12286 int arg3 ;
12287 bool arg4 = (bool) true ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 int val2 ;
12292 int ecode2 = 0 ;
12293 int val3 ;
12294 int ecode3 = 0 ;
12295 bool val4 ;
12296 int ecode4 = 0 ;
12297 PyObject * obj0 = 0 ;
12298 PyObject * obj1 = 0 ;
12299 PyObject * obj2 = 0 ;
12300 PyObject * obj3 = 0 ;
12301 char * kwnames[] = {
12302 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12303 };
12304
12305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12307 if (!SWIG_IsOK(res1)) {
12308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12309 }
12310 arg1 = reinterpret_cast< wxGrid * >(argp1);
12311 ecode2 = SWIG_AsVal_int(obj1, &val2);
12312 if (!SWIG_IsOK(ecode2)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12314 }
12315 arg2 = static_cast< int >(val2);
12316 ecode3 = SWIG_AsVal_int(obj2, &val3);
12317 if (!SWIG_IsOK(ecode3)) {
12318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12319 }
12320 arg3 = static_cast< int >(val3);
12321 if (obj3) {
12322 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12323 if (!SWIG_IsOK(ecode4)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12325 }
12326 arg4 = static_cast< bool >(val4);
12327 }
12328 {
12329 PyThreadState* __tstate = wxPyBeginAllowThreads();
12330 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 {
12335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj = 0;
12345 wxGrid *arg1 = (wxGrid *) 0 ;
12346 int arg2 ;
12347 int arg3 ;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 int val2 ;
12351 int ecode2 = 0 ;
12352 int val3 ;
12353 int ecode3 = 0 ;
12354 PyObject * obj0 = 0 ;
12355 PyObject * obj1 = 0 ;
12356 PyObject * obj2 = 0 ;
12357 char * kwnames[] = {
12358 (char *) "self",(char *) "row",(char *) "col", NULL
12359 };
12360
12361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12363 if (!SWIG_IsOK(res1)) {
12364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12365 }
12366 arg1 = reinterpret_cast< wxGrid * >(argp1);
12367 ecode2 = SWIG_AsVal_int(obj1, &val2);
12368 if (!SWIG_IsOK(ecode2)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12370 }
12371 arg2 = static_cast< int >(val2);
12372 ecode3 = SWIG_AsVal_int(obj2, &val3);
12373 if (!SWIG_IsOK(ecode3)) {
12374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12375 }
12376 arg3 = static_cast< int >(val3);
12377 {
12378 PyThreadState* __tstate = wxPyBeginAllowThreads();
12379 (arg1)->MakeCellVisible(arg2,arg3);
12380 wxPyEndAllowThreads(__tstate);
12381 if (PyErr_Occurred()) SWIG_fail;
12382 }
12383 resultobj = SWIG_Py_Void();
12384 return resultobj;
12385 fail:
12386 return NULL;
12387 }
12388
12389
12390 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12391 PyObject *resultobj = 0;
12392 wxGrid *arg1 = (wxGrid *) 0 ;
12393 int arg2 ;
12394 int arg3 ;
12395 void *argp1 = 0 ;
12396 int res1 = 0 ;
12397 int val2 ;
12398 int ecode2 = 0 ;
12399 int val3 ;
12400 int ecode3 = 0 ;
12401 PyObject * obj0 = 0 ;
12402 PyObject * obj1 = 0 ;
12403 PyObject * obj2 = 0 ;
12404 char * kwnames[] = {
12405 (char *) "self",(char *) "row",(char *) "col", NULL
12406 };
12407
12408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12410 if (!SWIG_IsOK(res1)) {
12411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12412 }
12413 arg1 = reinterpret_cast< wxGrid * >(argp1);
12414 ecode2 = SWIG_AsVal_int(obj1, &val2);
12415 if (!SWIG_IsOK(ecode2)) {
12416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12417 }
12418 arg2 = static_cast< int >(val2);
12419 ecode3 = SWIG_AsVal_int(obj2, &val3);
12420 if (!SWIG_IsOK(ecode3)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12422 }
12423 arg3 = static_cast< int >(val3);
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 (arg1)->SetGridCursor(arg2,arg3);
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_Py_Void();
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12438 PyObject *resultobj = 0;
12439 wxGrid *arg1 = (wxGrid *) 0 ;
12440 bool arg2 ;
12441 bool result;
12442 void *argp1 = 0 ;
12443 int res1 = 0 ;
12444 bool val2 ;
12445 int ecode2 = 0 ;
12446 PyObject * obj0 = 0 ;
12447 PyObject * obj1 = 0 ;
12448 char * kwnames[] = {
12449 (char *) "self",(char *) "expandSelection", NULL
12450 };
12451
12452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12456 }
12457 arg1 = reinterpret_cast< wxGrid * >(argp1);
12458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12459 if (!SWIG_IsOK(ecode2)) {
12460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12461 }
12462 arg2 = static_cast< bool >(val2);
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (bool)(arg1)->MoveCursorUp(arg2);
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj = 0;
12480 wxGrid *arg1 = (wxGrid *) 0 ;
12481 bool arg2 ;
12482 bool result;
12483 void *argp1 = 0 ;
12484 int res1 = 0 ;
12485 bool val2 ;
12486 int ecode2 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 char * kwnames[] = {
12490 (char *) "self",(char *) "expandSelection", NULL
12491 };
12492
12493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12495 if (!SWIG_IsOK(res1)) {
12496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12497 }
12498 arg1 = reinterpret_cast< wxGrid * >(argp1);
12499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12500 if (!SWIG_IsOK(ecode2)) {
12501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12502 }
12503 arg2 = static_cast< bool >(val2);
12504 {
12505 PyThreadState* __tstate = wxPyBeginAllowThreads();
12506 result = (bool)(arg1)->MoveCursorDown(arg2);
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj = 0;
12521 wxGrid *arg1 = (wxGrid *) 0 ;
12522 bool arg2 ;
12523 bool result;
12524 void *argp1 = 0 ;
12525 int res1 = 0 ;
12526 bool val2 ;
12527 int ecode2 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "expandSelection", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12538 }
12539 arg1 = reinterpret_cast< wxGrid * >(argp1);
12540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12541 if (!SWIG_IsOK(ecode2)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12543 }
12544 arg2 = static_cast< bool >(val2);
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = (bool)(arg1)->MoveCursorLeft(arg2);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12553 }
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj = 0;
12562 wxGrid *arg1 = (wxGrid *) 0 ;
12563 bool arg2 ;
12564 bool result;
12565 void *argp1 = 0 ;
12566 int res1 = 0 ;
12567 bool val2 ;
12568 int ecode2 = 0 ;
12569 PyObject * obj0 = 0 ;
12570 PyObject * obj1 = 0 ;
12571 char * kwnames[] = {
12572 (char *) "self",(char *) "expandSelection", NULL
12573 };
12574
12575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12577 if (!SWIG_IsOK(res1)) {
12578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12579 }
12580 arg1 = reinterpret_cast< wxGrid * >(argp1);
12581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12582 if (!SWIG_IsOK(ecode2)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12584 }
12585 arg2 = static_cast< bool >(val2);
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (bool)(arg1)->MoveCursorRight(arg2);
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12602 PyObject *resultobj = 0;
12603 wxGrid *arg1 = (wxGrid *) 0 ;
12604 bool result;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 PyObject *swig_obj[1] ;
12608
12609 if (!args) SWIG_fail;
12610 swig_obj[0] = args;
12611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12614 }
12615 arg1 = reinterpret_cast< wxGrid * >(argp1);
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->MovePageDown();
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633 wxGrid *arg1 = (wxGrid *) 0 ;
12634 bool result;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 PyObject *swig_obj[1] ;
12638
12639 if (!args) SWIG_fail;
12640 swig_obj[0] = args;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12644 }
12645 arg1 = reinterpret_cast< wxGrid * >(argp1);
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (bool)(arg1)->MovePageUp();
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_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12662 PyObject *resultobj = 0;
12663 wxGrid *arg1 = (wxGrid *) 0 ;
12664 bool arg2 ;
12665 bool result;
12666 void *argp1 = 0 ;
12667 int res1 = 0 ;
12668 bool val2 ;
12669 int ecode2 = 0 ;
12670 PyObject * obj0 = 0 ;
12671 PyObject * obj1 = 0 ;
12672 char * kwnames[] = {
12673 (char *) "self",(char *) "expandSelection", NULL
12674 };
12675
12676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12678 if (!SWIG_IsOK(res1)) {
12679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12680 }
12681 arg1 = reinterpret_cast< wxGrid * >(argp1);
12682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12683 if (!SWIG_IsOK(ecode2)) {
12684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12685 }
12686 arg2 = static_cast< bool >(val2);
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 {
12694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj = 0;
12704 wxGrid *arg1 = (wxGrid *) 0 ;
12705 bool arg2 ;
12706 bool result;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 bool val2 ;
12710 int ecode2 = 0 ;
12711 PyObject * obj0 = 0 ;
12712 PyObject * obj1 = 0 ;
12713 char * kwnames[] = {
12714 (char *) "self",(char *) "expandSelection", NULL
12715 };
12716
12717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12721 }
12722 arg1 = reinterpret_cast< wxGrid * >(argp1);
12723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12724 if (!SWIG_IsOK(ecode2)) {
12725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12726 }
12727 arg2 = static_cast< bool >(val2);
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj = 0;
12745 wxGrid *arg1 = (wxGrid *) 0 ;
12746 bool arg2 ;
12747 bool result;
12748 void *argp1 = 0 ;
12749 int res1 = 0 ;
12750 bool val2 ;
12751 int ecode2 = 0 ;
12752 PyObject * obj0 = 0 ;
12753 PyObject * obj1 = 0 ;
12754 char * kwnames[] = {
12755 (char *) "self",(char *) "expandSelection", NULL
12756 };
12757
12758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12762 }
12763 arg1 = reinterpret_cast< wxGrid * >(argp1);
12764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12765 if (!SWIG_IsOK(ecode2)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12767 }
12768 arg2 = static_cast< bool >(val2);
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 {
12776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12777 }
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj = 0;
12786 wxGrid *arg1 = (wxGrid *) 0 ;
12787 bool arg2 ;
12788 bool result;
12789 void *argp1 = 0 ;
12790 int res1 = 0 ;
12791 bool val2 ;
12792 int ecode2 = 0 ;
12793 PyObject * obj0 = 0 ;
12794 PyObject * obj1 = 0 ;
12795 char * kwnames[] = {
12796 (char *) "self",(char *) "expandSelection", NULL
12797 };
12798
12799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12803 }
12804 arg1 = reinterpret_cast< wxGrid * >(argp1);
12805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12806 if (!SWIG_IsOK(ecode2)) {
12807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12808 }
12809 arg2 = static_cast< bool >(val2);
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *resultobj = 0;
12827 wxGrid *arg1 = (wxGrid *) 0 ;
12828 int result;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 PyObject *swig_obj[1] ;
12832
12833 if (!args) SWIG_fail;
12834 swig_obj[0] = args;
12835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12838 }
12839 arg1 = reinterpret_cast< wxGrid * >(argp1);
12840 {
12841 PyThreadState* __tstate = wxPyBeginAllowThreads();
12842 result = (int)(arg1)->GetDefaultRowLabelSize();
12843 wxPyEndAllowThreads(__tstate);
12844 if (PyErr_Occurred()) SWIG_fail;
12845 }
12846 resultobj = SWIG_From_int(static_cast< int >(result));
12847 return resultobj;
12848 fail:
12849 return NULL;
12850 }
12851
12852
12853 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854 PyObject *resultobj = 0;
12855 wxGrid *arg1 = (wxGrid *) 0 ;
12856 int result;
12857 void *argp1 = 0 ;
12858 int res1 = 0 ;
12859 PyObject *swig_obj[1] ;
12860
12861 if (!args) SWIG_fail;
12862 swig_obj[0] = args;
12863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12864 if (!SWIG_IsOK(res1)) {
12865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12866 }
12867 arg1 = reinterpret_cast< wxGrid * >(argp1);
12868 {
12869 PyThreadState* __tstate = wxPyBeginAllowThreads();
12870 result = (int)(arg1)->GetRowLabelSize();
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 resultobj = SWIG_From_int(static_cast< int >(result));
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *resultobj = 0;
12883 wxGrid *arg1 = (wxGrid *) 0 ;
12884 int result;
12885 void *argp1 = 0 ;
12886 int res1 = 0 ;
12887 PyObject *swig_obj[1] ;
12888
12889 if (!args) SWIG_fail;
12890 swig_obj[0] = args;
12891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12892 if (!SWIG_IsOK(res1)) {
12893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12894 }
12895 arg1 = reinterpret_cast< wxGrid * >(argp1);
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = (int)(arg1)->GetDefaultColLabelSize();
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_From_int(static_cast< int >(result));
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 PyObject *resultobj = 0;
12911 wxGrid *arg1 = (wxGrid *) 0 ;
12912 int result;
12913 void *argp1 = 0 ;
12914 int res1 = 0 ;
12915 PyObject *swig_obj[1] ;
12916
12917 if (!args) SWIG_fail;
12918 swig_obj[0] = args;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12922 }
12923 arg1 = reinterpret_cast< wxGrid * >(argp1);
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = (int)(arg1)->GetColLabelSize();
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 resultobj = SWIG_From_int(static_cast< int >(result));
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxGrid *arg1 = (wxGrid *) 0 ;
12940 wxColour result;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject *swig_obj[1] ;
12944
12945 if (!args) SWIG_fail;
12946 swig_obj[0] = args;
12947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12950 }
12951 arg1 = reinterpret_cast< wxGrid * >(argp1);
12952 {
12953 PyThreadState* __tstate = wxPyBeginAllowThreads();
12954 result = (arg1)->GetLabelBackgroundColour();
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12966 PyObject *resultobj = 0;
12967 wxGrid *arg1 = (wxGrid *) 0 ;
12968 wxColour result;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 PyObject *swig_obj[1] ;
12972
12973 if (!args) SWIG_fail;
12974 swig_obj[0] = args;
12975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12976 if (!SWIG_IsOK(res1)) {
12977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12978 }
12979 arg1 = reinterpret_cast< wxGrid * >(argp1);
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 result = (arg1)->GetLabelTextColour();
12983 wxPyEndAllowThreads(__tstate);
12984 if (PyErr_Occurred()) SWIG_fail;
12985 }
12986 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12994 PyObject *resultobj = 0;
12995 wxGrid *arg1 = (wxGrid *) 0 ;
12996 wxFont result;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 PyObject *swig_obj[1] ;
13000
13001 if (!args) SWIG_fail;
13002 swig_obj[0] = args;
13003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13004 if (!SWIG_IsOK(res1)) {
13005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13006 }
13007 arg1 = reinterpret_cast< wxGrid * >(argp1);
13008 {
13009 PyThreadState* __tstate = wxPyBeginAllowThreads();
13010 result = (arg1)->GetLabelFont();
13011 wxPyEndAllowThreads(__tstate);
13012 if (PyErr_Occurred()) SWIG_fail;
13013 }
13014 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 PyObject *resultobj = 0;
13023 wxGrid *arg1 = (wxGrid *) 0 ;
13024 int *arg2 = (int *) 0 ;
13025 int *arg3 = (int *) 0 ;
13026 void *argp1 = 0 ;
13027 int res1 = 0 ;
13028 int temp2 ;
13029 int res2 = SWIG_TMPOBJ ;
13030 int temp3 ;
13031 int res3 = SWIG_TMPOBJ ;
13032 PyObject *swig_obj[1] ;
13033
13034 arg2 = &temp2;
13035 arg3 = &temp3;
13036 if (!args) SWIG_fail;
13037 swig_obj[0] = args;
13038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13039 if (!SWIG_IsOK(res1)) {
13040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13041 }
13042 arg1 = reinterpret_cast< wxGrid * >(argp1);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 (arg1)->GetRowLabelAlignment(arg2,arg3);
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 resultobj = SWIG_Py_Void();
13050 if (SWIG_IsTmpObj(res2)) {
13051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13052 } else {
13053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13055 }
13056 if (SWIG_IsTmpObj(res3)) {
13057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13058 } else {
13059 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13061 }
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *resultobj = 0;
13070 wxGrid *arg1 = (wxGrid *) 0 ;
13071 int *arg2 = (int *) 0 ;
13072 int *arg3 = (int *) 0 ;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 int temp2 ;
13076 int res2 = SWIG_TMPOBJ ;
13077 int temp3 ;
13078 int res3 = SWIG_TMPOBJ ;
13079 PyObject *swig_obj[1] ;
13080
13081 arg2 = &temp2;
13082 arg3 = &temp3;
13083 if (!args) SWIG_fail;
13084 swig_obj[0] = args;
13085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13086 if (!SWIG_IsOK(res1)) {
13087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13088 }
13089 arg1 = reinterpret_cast< wxGrid * >(argp1);
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 (arg1)->GetColLabelAlignment(arg2,arg3);
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 resultobj = SWIG_Py_Void();
13097 if (SWIG_IsTmpObj(res2)) {
13098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13099 } else {
13100 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13102 }
13103 if (SWIG_IsTmpObj(res3)) {
13104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13105 } else {
13106 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13108 }
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13116 PyObject *resultobj = 0;
13117 wxGrid *arg1 = (wxGrid *) 0 ;
13118 int result;
13119 void *argp1 = 0 ;
13120 int res1 = 0 ;
13121 PyObject *swig_obj[1] ;
13122
13123 if (!args) SWIG_fail;
13124 swig_obj[0] = args;
13125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13126 if (!SWIG_IsOK(res1)) {
13127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13128 }
13129 arg1 = reinterpret_cast< wxGrid * >(argp1);
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 result = (int)(arg1)->GetColLabelTextOrientation();
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 resultobj = SWIG_From_int(static_cast< int >(result));
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 wxGrid *arg1 = (wxGrid *) 0 ;
13146 int arg2 ;
13147 wxString result;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 int val2 ;
13151 int ecode2 = 0 ;
13152 PyObject * obj0 = 0 ;
13153 PyObject * obj1 = 0 ;
13154 char * kwnames[] = {
13155 (char *) "self",(char *) "row", NULL
13156 };
13157
13158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13162 }
13163 arg1 = reinterpret_cast< wxGrid * >(argp1);
13164 ecode2 = SWIG_AsVal_int(obj1, &val2);
13165 if (!SWIG_IsOK(ecode2)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13167 }
13168 arg2 = static_cast< int >(val2);
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (arg1)->GetRowLabelValue(arg2);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 {
13176 #if wxUSE_UNICODE
13177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13178 #else
13179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13180 #endif
13181 }
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj = 0;
13190 wxGrid *arg1 = (wxGrid *) 0 ;
13191 int arg2 ;
13192 wxString result;
13193 void *argp1 = 0 ;
13194 int res1 = 0 ;
13195 int val2 ;
13196 int ecode2 = 0 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "self",(char *) "col", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13205 if (!SWIG_IsOK(res1)) {
13206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13207 }
13208 arg1 = reinterpret_cast< wxGrid * >(argp1);
13209 ecode2 = SWIG_AsVal_int(obj1, &val2);
13210 if (!SWIG_IsOK(ecode2)) {
13211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13212 }
13213 arg2 = static_cast< int >(val2);
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 result = (arg1)->GetColLabelValue(arg2);
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 {
13221 #if wxUSE_UNICODE
13222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13223 #else
13224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13225 #endif
13226 }
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234 PyObject *resultobj = 0;
13235 wxGrid *arg1 = (wxGrid *) 0 ;
13236 wxColour result;
13237 void *argp1 = 0 ;
13238 int res1 = 0 ;
13239 PyObject *swig_obj[1] ;
13240
13241 if (!args) SWIG_fail;
13242 swig_obj[0] = args;
13243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13244 if (!SWIG_IsOK(res1)) {
13245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13246 }
13247 arg1 = reinterpret_cast< wxGrid * >(argp1);
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 result = (arg1)->GetGridLineColour();
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13262 PyObject *resultobj = 0;
13263 wxGrid *arg1 = (wxGrid *) 0 ;
13264 wxPen result;
13265 void *argp1 = 0 ;
13266 int res1 = 0 ;
13267 PyObject *swig_obj[1] ;
13268
13269 if (!args) SWIG_fail;
13270 swig_obj[0] = args;
13271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13274 }
13275 arg1 = reinterpret_cast< wxGrid * >(argp1);
13276 {
13277 PyThreadState* __tstate = wxPyBeginAllowThreads();
13278 result = (arg1)->GetDefaultGridLinePen();
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13283 return resultobj;
13284 fail:
13285 return NULL;
13286 }
13287
13288
13289 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13290 PyObject *resultobj = 0;
13291 wxGrid *arg1 = (wxGrid *) 0 ;
13292 int arg2 ;
13293 wxPen result;
13294 void *argp1 = 0 ;
13295 int res1 = 0 ;
13296 int val2 ;
13297 int ecode2 = 0 ;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 char * kwnames[] = {
13301 (char *) "self",(char *) "row", NULL
13302 };
13303
13304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13306 if (!SWIG_IsOK(res1)) {
13307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13308 }
13309 arg1 = reinterpret_cast< wxGrid * >(argp1);
13310 ecode2 = SWIG_AsVal_int(obj1, &val2);
13311 if (!SWIG_IsOK(ecode2)) {
13312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13313 }
13314 arg2 = static_cast< int >(val2);
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (arg1)->GetRowGridLinePen(arg2);
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = 0;
13330 wxGrid *arg1 = (wxGrid *) 0 ;
13331 int arg2 ;
13332 wxPen result;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 int val2 ;
13336 int ecode2 = 0 ;
13337 PyObject * obj0 = 0 ;
13338 PyObject * obj1 = 0 ;
13339 char * kwnames[] = {
13340 (char *) "self",(char *) "col", NULL
13341 };
13342
13343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",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_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13347 }
13348 arg1 = reinterpret_cast< wxGrid * >(argp1);
13349 ecode2 = SWIG_AsVal_int(obj1, &val2);
13350 if (!SWIG_IsOK(ecode2)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13352 }
13353 arg2 = static_cast< int >(val2);
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = (arg1)->GetColGridLinePen(arg2);
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13368 PyObject *resultobj = 0;
13369 wxGrid *arg1 = (wxGrid *) 0 ;
13370 wxColour result;
13371 void *argp1 = 0 ;
13372 int res1 = 0 ;
13373 PyObject *swig_obj[1] ;
13374
13375 if (!args) SWIG_fail;
13376 swig_obj[0] = args;
13377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13378 if (!SWIG_IsOK(res1)) {
13379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13380 }
13381 arg1 = reinterpret_cast< wxGrid * >(argp1);
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = (arg1)->GetCellHighlightColour();
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13389 return resultobj;
13390 fail:
13391 return NULL;
13392 }
13393
13394
13395 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13396 PyObject *resultobj = 0;
13397 wxGrid *arg1 = (wxGrid *) 0 ;
13398 int result;
13399 void *argp1 = 0 ;
13400 int res1 = 0 ;
13401 PyObject *swig_obj[1] ;
13402
13403 if (!args) SWIG_fail;
13404 swig_obj[0] = args;
13405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13406 if (!SWIG_IsOK(res1)) {
13407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13408 }
13409 arg1 = reinterpret_cast< wxGrid * >(argp1);
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (int)(arg1)->GetCellHighlightPenWidth();
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 resultobj = SWIG_From_int(static_cast< int >(result));
13417 return resultobj;
13418 fail:
13419 return NULL;
13420 }
13421
13422
13423 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13424 PyObject *resultobj = 0;
13425 wxGrid *arg1 = (wxGrid *) 0 ;
13426 int result;
13427 void *argp1 = 0 ;
13428 int res1 = 0 ;
13429 PyObject *swig_obj[1] ;
13430
13431 if (!args) SWIG_fail;
13432 swig_obj[0] = args;
13433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13434 if (!SWIG_IsOK(res1)) {
13435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13436 }
13437 arg1 = reinterpret_cast< wxGrid * >(argp1);
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (int)(arg1)->GetCellHighlightROPenWidth();
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_From_int(static_cast< int >(result));
13445 return resultobj;
13446 fail:
13447 return NULL;
13448 }
13449
13450
13451 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj = 0;
13453 wxGrid *arg1 = (wxGrid *) 0 ;
13454 int arg2 ;
13455 void *argp1 = 0 ;
13456 int res1 = 0 ;
13457 int val2 ;
13458 int ecode2 = 0 ;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char * kwnames[] = {
13462 (char *) "self",(char *) "width", NULL
13463 };
13464
13465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13467 if (!SWIG_IsOK(res1)) {
13468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13469 }
13470 arg1 = reinterpret_cast< wxGrid * >(argp1);
13471 ecode2 = SWIG_AsVal_int(obj1, &val2);
13472 if (!SWIG_IsOK(ecode2)) {
13473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13474 }
13475 arg2 = static_cast< int >(val2);
13476 {
13477 PyThreadState* __tstate = wxPyBeginAllowThreads();
13478 (arg1)->SetRowLabelSize(arg2);
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 resultobj = SWIG_Py_Void();
13483 return resultobj;
13484 fail:
13485 return NULL;
13486 }
13487
13488
13489 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13490 PyObject *resultobj = 0;
13491 wxGrid *arg1 = (wxGrid *) 0 ;
13492 int arg2 ;
13493 void *argp1 = 0 ;
13494 int res1 = 0 ;
13495 int val2 ;
13496 int ecode2 = 0 ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 char * kwnames[] = {
13500 (char *) "self",(char *) "height", NULL
13501 };
13502
13503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13505 if (!SWIG_IsOK(res1)) {
13506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13507 }
13508 arg1 = reinterpret_cast< wxGrid * >(argp1);
13509 ecode2 = SWIG_AsVal_int(obj1, &val2);
13510 if (!SWIG_IsOK(ecode2)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13512 }
13513 arg2 = static_cast< int >(val2);
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 (arg1)->SetColLabelSize(arg2);
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 resultobj = SWIG_Py_Void();
13521 return resultobj;
13522 fail:
13523 return NULL;
13524 }
13525
13526
13527 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13528 PyObject *resultobj = 0;
13529 wxGrid *arg1 = (wxGrid *) 0 ;
13530 wxColour *arg2 = 0 ;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 wxColour temp2 ;
13534 PyObject * obj0 = 0 ;
13535 PyObject * obj1 = 0 ;
13536 char * kwnames[] = {
13537 (char *) "self",(char *)"arg2", NULL
13538 };
13539
13540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13542 if (!SWIG_IsOK(res1)) {
13543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13544 }
13545 arg1 = reinterpret_cast< wxGrid * >(argp1);
13546 {
13547 arg2 = &temp2;
13548 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13549 }
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_Py_Void();
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj = 0;
13565 wxGrid *arg1 = (wxGrid *) 0 ;
13566 wxColour *arg2 = 0 ;
13567 void *argp1 = 0 ;
13568 int res1 = 0 ;
13569 wxColour temp2 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 char * kwnames[] = {
13573 (char *) "self",(char *)"arg2", NULL
13574 };
13575
13576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13578 if (!SWIG_IsOK(res1)) {
13579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13580 }
13581 arg1 = reinterpret_cast< wxGrid * >(argp1);
13582 {
13583 arg2 = &temp2;
13584 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13585 }
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 resultobj = SWIG_Py_Void();
13593 return resultobj;
13594 fail:
13595 return NULL;
13596 }
13597
13598
13599 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj = 0;
13601 wxGrid *arg1 = (wxGrid *) 0 ;
13602 wxFont *arg2 = 0 ;
13603 void *argp1 = 0 ;
13604 int res1 = 0 ;
13605 void *argp2 = 0 ;
13606 int res2 = 0 ;
13607 PyObject * obj0 = 0 ;
13608 PyObject * obj1 = 0 ;
13609 char * kwnames[] = {
13610 (char *) "self",(char *)"arg2", NULL
13611 };
13612
13613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13615 if (!SWIG_IsOK(res1)) {
13616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13617 }
13618 arg1 = reinterpret_cast< wxGrid * >(argp1);
13619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13620 if (!SWIG_IsOK(res2)) {
13621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13622 }
13623 if (!argp2) {
13624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13625 }
13626 arg2 = reinterpret_cast< wxFont * >(argp2);
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 (arg1)->SetLabelFont((wxFont const &)*arg2);
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_Py_Void();
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj = 0;
13642 wxGrid *arg1 = (wxGrid *) 0 ;
13643 int arg2 ;
13644 int arg3 ;
13645 void *argp1 = 0 ;
13646 int res1 = 0 ;
13647 int val2 ;
13648 int ecode2 = 0 ;
13649 int val3 ;
13650 int ecode3 = 0 ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13662 }
13663 arg1 = reinterpret_cast< wxGrid * >(argp1);
13664 ecode2 = SWIG_AsVal_int(obj1, &val2);
13665 if (!SWIG_IsOK(ecode2)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13667 }
13668 arg2 = static_cast< int >(val2);
13669 ecode3 = SWIG_AsVal_int(obj2, &val3);
13670 if (!SWIG_IsOK(ecode3)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13672 }
13673 arg3 = static_cast< int >(val3);
13674 {
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 (arg1)->SetRowLabelAlignment(arg2,arg3);
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 resultobj = SWIG_Py_Void();
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj = 0;
13689 wxGrid *arg1 = (wxGrid *) 0 ;
13690 int arg2 ;
13691 int arg3 ;
13692 void *argp1 = 0 ;
13693 int res1 = 0 ;
13694 int val2 ;
13695 int ecode2 = 0 ;
13696 int val3 ;
13697 int ecode3 = 0 ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 PyObject * obj2 = 0 ;
13701 char * kwnames[] = {
13702 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13703 };
13704
13705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13707 if (!SWIG_IsOK(res1)) {
13708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13709 }
13710 arg1 = reinterpret_cast< wxGrid * >(argp1);
13711 ecode2 = SWIG_AsVal_int(obj1, &val2);
13712 if (!SWIG_IsOK(ecode2)) {
13713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13714 }
13715 arg2 = static_cast< int >(val2);
13716 ecode3 = SWIG_AsVal_int(obj2, &val3);
13717 if (!SWIG_IsOK(ecode3)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13719 }
13720 arg3 = static_cast< int >(val3);
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 (arg1)->SetColLabelAlignment(arg2,arg3);
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 resultobj = SWIG_Py_Void();
13728 return resultobj;
13729 fail:
13730 return NULL;
13731 }
13732
13733
13734 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13735 PyObject *resultobj = 0;
13736 wxGrid *arg1 = (wxGrid *) 0 ;
13737 int arg2 ;
13738 void *argp1 = 0 ;
13739 int res1 = 0 ;
13740 int val2 ;
13741 int ecode2 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 char * kwnames[] = {
13745 (char *) "self",(char *) "textOrientation", NULL
13746 };
13747
13748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13750 if (!SWIG_IsOK(res1)) {
13751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13752 }
13753 arg1 = reinterpret_cast< wxGrid * >(argp1);
13754 ecode2 = SWIG_AsVal_int(obj1, &val2);
13755 if (!SWIG_IsOK(ecode2)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13757 }
13758 arg2 = static_cast< int >(val2);
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 (arg1)->SetColLabelTextOrientation(arg2);
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 resultobj = SWIG_Py_Void();
13766 return resultobj;
13767 fail:
13768 return NULL;
13769 }
13770
13771
13772 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj = 0;
13774 wxGrid *arg1 = (wxGrid *) 0 ;
13775 int arg2 ;
13776 wxString *arg3 = 0 ;
13777 void *argp1 = 0 ;
13778 int res1 = 0 ;
13779 int val2 ;
13780 int ecode2 = 0 ;
13781 bool temp3 = false ;
13782 PyObject * obj0 = 0 ;
13783 PyObject * obj1 = 0 ;
13784 PyObject * obj2 = 0 ;
13785 char * kwnames[] = {
13786 (char *) "self",(char *) "row",(char *)"arg3", NULL
13787 };
13788
13789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13791 if (!SWIG_IsOK(res1)) {
13792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13793 }
13794 arg1 = reinterpret_cast< wxGrid * >(argp1);
13795 ecode2 = SWIG_AsVal_int(obj1, &val2);
13796 if (!SWIG_IsOK(ecode2)) {
13797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13798 }
13799 arg2 = static_cast< int >(val2);
13800 {
13801 arg3 = wxString_in_helper(obj2);
13802 if (arg3 == NULL) SWIG_fail;
13803 temp3 = true;
13804 }
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 resultobj = SWIG_Py_Void();
13812 {
13813 if (temp3)
13814 delete arg3;
13815 }
13816 return resultobj;
13817 fail:
13818 {
13819 if (temp3)
13820 delete arg3;
13821 }
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxGrid *arg1 = (wxGrid *) 0 ;
13829 int arg2 ;
13830 wxString *arg3 = 0 ;
13831 void *argp1 = 0 ;
13832 int res1 = 0 ;
13833 int val2 ;
13834 int ecode2 = 0 ;
13835 bool temp3 = false ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "self",(char *) "col",(char *)"arg3", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13847 }
13848 arg1 = reinterpret_cast< wxGrid * >(argp1);
13849 ecode2 = SWIG_AsVal_int(obj1, &val2);
13850 if (!SWIG_IsOK(ecode2)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13852 }
13853 arg2 = static_cast< int >(val2);
13854 {
13855 arg3 = wxString_in_helper(obj2);
13856 if (arg3 == NULL) SWIG_fail;
13857 temp3 = true;
13858 }
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_Py_Void();
13866 {
13867 if (temp3)
13868 delete arg3;
13869 }
13870 return resultobj;
13871 fail:
13872 {
13873 if (temp3)
13874 delete arg3;
13875 }
13876 return NULL;
13877 }
13878
13879
13880 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13881 PyObject *resultobj = 0;
13882 wxGrid *arg1 = (wxGrid *) 0 ;
13883 wxColour *arg2 = 0 ;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 wxColour temp2 ;
13887 PyObject * obj0 = 0 ;
13888 PyObject * obj1 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *)"arg2", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13897 }
13898 arg1 = reinterpret_cast< wxGrid * >(argp1);
13899 {
13900 arg2 = &temp2;
13901 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13902 }
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 resultobj = SWIG_Py_Void();
13910 return resultobj;
13911 fail:
13912 return NULL;
13913 }
13914
13915
13916 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj = 0;
13918 wxGrid *arg1 = (wxGrid *) 0 ;
13919 wxColour *arg2 = 0 ;
13920 void *argp1 = 0 ;
13921 int res1 = 0 ;
13922 wxColour temp2 ;
13923 PyObject * obj0 = 0 ;
13924 PyObject * obj1 = 0 ;
13925 char * kwnames[] = {
13926 (char *) "self",(char *)"arg2", NULL
13927 };
13928
13929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13931 if (!SWIG_IsOK(res1)) {
13932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13933 }
13934 arg1 = reinterpret_cast< wxGrid * >(argp1);
13935 {
13936 arg2 = &temp2;
13937 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13938 }
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 resultobj = SWIG_Py_Void();
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13953 PyObject *resultobj = 0;
13954 wxGrid *arg1 = (wxGrid *) 0 ;
13955 int arg2 ;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 int val2 ;
13959 int ecode2 = 0 ;
13960 PyObject * obj0 = 0 ;
13961 PyObject * obj1 = 0 ;
13962 char * kwnames[] = {
13963 (char *) "self",(char *) "width", NULL
13964 };
13965
13966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",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_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13970 }
13971 arg1 = reinterpret_cast< wxGrid * >(argp1);
13972 ecode2 = SWIG_AsVal_int(obj1, &val2);
13973 if (!SWIG_IsOK(ecode2)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13975 }
13976 arg2 = static_cast< int >(val2);
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 (arg1)->SetCellHighlightPenWidth(arg2);
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_Py_Void();
13984 return resultobj;
13985 fail:
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13991 PyObject *resultobj = 0;
13992 wxGrid *arg1 = (wxGrid *) 0 ;
13993 int arg2 ;
13994 void *argp1 = 0 ;
13995 int res1 = 0 ;
13996 int val2 ;
13997 int ecode2 = 0 ;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 char * kwnames[] = {
14001 (char *) "self",(char *) "width", NULL
14002 };
14003
14004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14008 }
14009 arg1 = reinterpret_cast< wxGrid * >(argp1);
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14013 }
14014 arg2 = static_cast< int >(val2);
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 (arg1)->SetCellHighlightROPenWidth(arg2);
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_Py_Void();
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj = 0;
14030 wxGrid *arg1 = (wxGrid *) 0 ;
14031 bool arg2 = (bool) true ;
14032 void *argp1 = 0 ;
14033 int res1 = 0 ;
14034 bool val2 ;
14035 int ecode2 = 0 ;
14036 PyObject * obj0 = 0 ;
14037 PyObject * obj1 = 0 ;
14038 char * kwnames[] = {
14039 (char *) "self",(char *) "enable", NULL
14040 };
14041
14042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14044 if (!SWIG_IsOK(res1)) {
14045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14046 }
14047 arg1 = reinterpret_cast< wxGrid * >(argp1);
14048 if (obj1) {
14049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14050 if (!SWIG_IsOK(ecode2)) {
14051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14052 }
14053 arg2 = static_cast< bool >(val2);
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 (arg1)->EnableDragRowSize(arg2);
14058 wxPyEndAllowThreads(__tstate);
14059 if (PyErr_Occurred()) SWIG_fail;
14060 }
14061 resultobj = SWIG_Py_Void();
14062 return resultobj;
14063 fail:
14064 return NULL;
14065 }
14066
14067
14068 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14069 PyObject *resultobj = 0;
14070 wxGrid *arg1 = (wxGrid *) 0 ;
14071 void *argp1 = 0 ;
14072 int res1 = 0 ;
14073 PyObject *swig_obj[1] ;
14074
14075 if (!args) SWIG_fail;
14076 swig_obj[0] = args;
14077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14078 if (!SWIG_IsOK(res1)) {
14079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14080 }
14081 arg1 = reinterpret_cast< wxGrid * >(argp1);
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 (arg1)->DisableDragRowSize();
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 resultobj = SWIG_Py_Void();
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14096 PyObject *resultobj = 0;
14097 wxGrid *arg1 = (wxGrid *) 0 ;
14098 bool result;
14099 void *argp1 = 0 ;
14100 int res1 = 0 ;
14101 PyObject *swig_obj[1] ;
14102
14103 if (!args) SWIG_fail;
14104 swig_obj[0] = args;
14105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14108 }
14109 arg1 = reinterpret_cast< wxGrid * >(argp1);
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 result = (bool)(arg1)->CanDragRowSize();
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj = 0;
14127 wxGrid *arg1 = (wxGrid *) 0 ;
14128 bool arg2 = (bool) true ;
14129 void *argp1 = 0 ;
14130 int res1 = 0 ;
14131 bool val2 ;
14132 int ecode2 = 0 ;
14133 PyObject * obj0 = 0 ;
14134 PyObject * obj1 = 0 ;
14135 char * kwnames[] = {
14136 (char *) "self",(char *) "enable", NULL
14137 };
14138
14139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14141 if (!SWIG_IsOK(res1)) {
14142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14143 }
14144 arg1 = reinterpret_cast< wxGrid * >(argp1);
14145 if (obj1) {
14146 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14147 if (!SWIG_IsOK(ecode2)) {
14148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14149 }
14150 arg2 = static_cast< bool >(val2);
14151 }
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 (arg1)->EnableDragColSize(arg2);
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 resultobj = SWIG_Py_Void();
14159 return resultobj;
14160 fail:
14161 return NULL;
14162 }
14163
14164
14165 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14166 PyObject *resultobj = 0;
14167 wxGrid *arg1 = (wxGrid *) 0 ;
14168 void *argp1 = 0 ;
14169 int res1 = 0 ;
14170 PyObject *swig_obj[1] ;
14171
14172 if (!args) SWIG_fail;
14173 swig_obj[0] = args;
14174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14175 if (!SWIG_IsOK(res1)) {
14176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14177 }
14178 arg1 = reinterpret_cast< wxGrid * >(argp1);
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 (arg1)->DisableDragColSize();
14182 wxPyEndAllowThreads(__tstate);
14183 if (PyErr_Occurred()) SWIG_fail;
14184 }
14185 resultobj = SWIG_Py_Void();
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14193 PyObject *resultobj = 0;
14194 wxGrid *arg1 = (wxGrid *) 0 ;
14195 bool result;
14196 void *argp1 = 0 ;
14197 int res1 = 0 ;
14198 PyObject *swig_obj[1] ;
14199
14200 if (!args) SWIG_fail;
14201 swig_obj[0] = args;
14202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14203 if (!SWIG_IsOK(res1)) {
14204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14205 }
14206 arg1 = reinterpret_cast< wxGrid * >(argp1);
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 result = (bool)(arg1)->CanDragColSize();
14210 wxPyEndAllowThreads(__tstate);
14211 if (PyErr_Occurred()) SWIG_fail;
14212 }
14213 {
14214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14215 }
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj = 0;
14224 wxGrid *arg1 = (wxGrid *) 0 ;
14225 bool arg2 = (bool) true ;
14226 void *argp1 = 0 ;
14227 int res1 = 0 ;
14228 bool val2 ;
14229 int ecode2 = 0 ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 char * kwnames[] = {
14233 (char *) "self",(char *) "enable", NULL
14234 };
14235
14236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14238 if (!SWIG_IsOK(res1)) {
14239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14240 }
14241 arg1 = reinterpret_cast< wxGrid * >(argp1);
14242 if (obj1) {
14243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14244 if (!SWIG_IsOK(ecode2)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14246 }
14247 arg2 = static_cast< bool >(val2);
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 (arg1)->EnableDragColMove(arg2);
14252 wxPyEndAllowThreads(__tstate);
14253 if (PyErr_Occurred()) SWIG_fail;
14254 }
14255 resultobj = SWIG_Py_Void();
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14263 PyObject *resultobj = 0;
14264 wxGrid *arg1 = (wxGrid *) 0 ;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 PyObject *swig_obj[1] ;
14268
14269 if (!args) SWIG_fail;
14270 swig_obj[0] = args;
14271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14272 if (!SWIG_IsOK(res1)) {
14273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14274 }
14275 arg1 = reinterpret_cast< wxGrid * >(argp1);
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 (arg1)->DisableDragColMove();
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 resultobj = SWIG_Py_Void();
14283 return resultobj;
14284 fail:
14285 return NULL;
14286 }
14287
14288
14289 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14290 PyObject *resultobj = 0;
14291 wxGrid *arg1 = (wxGrid *) 0 ;
14292 bool result;
14293 void *argp1 = 0 ;
14294 int res1 = 0 ;
14295 PyObject *swig_obj[1] ;
14296
14297 if (!args) SWIG_fail;
14298 swig_obj[0] = args;
14299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14302 }
14303 arg1 = reinterpret_cast< wxGrid * >(argp1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (bool)(arg1)->CanDragColMove();
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxGrid *arg1 = (wxGrid *) 0 ;
14322 bool arg2 = (bool) true ;
14323 void *argp1 = 0 ;
14324 int res1 = 0 ;
14325 bool val2 ;
14326 int ecode2 = 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 char * kwnames[] = {
14330 (char *) "self",(char *) "enable", NULL
14331 };
14332
14333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14335 if (!SWIG_IsOK(res1)) {
14336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14337 }
14338 arg1 = reinterpret_cast< wxGrid * >(argp1);
14339 if (obj1) {
14340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14341 if (!SWIG_IsOK(ecode2)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14343 }
14344 arg2 = static_cast< bool >(val2);
14345 }
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 (arg1)->EnableDragGridSize(arg2);
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 resultobj = SWIG_Py_Void();
14353 return resultobj;
14354 fail:
14355 return NULL;
14356 }
14357
14358
14359 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14360 PyObject *resultobj = 0;
14361 wxGrid *arg1 = (wxGrid *) 0 ;
14362 void *argp1 = 0 ;
14363 int res1 = 0 ;
14364 PyObject *swig_obj[1] ;
14365
14366 if (!args) SWIG_fail;
14367 swig_obj[0] = args;
14368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14371 }
14372 arg1 = reinterpret_cast< wxGrid * >(argp1);
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 (arg1)->DisableDragGridSize();
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = SWIG_Py_Void();
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14387 PyObject *resultobj = 0;
14388 wxGrid *arg1 = (wxGrid *) 0 ;
14389 bool result;
14390 void *argp1 = 0 ;
14391 int res1 = 0 ;
14392 PyObject *swig_obj[1] ;
14393
14394 if (!args) SWIG_fail;
14395 swig_obj[0] = args;
14396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14397 if (!SWIG_IsOK(res1)) {
14398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14399 }
14400 arg1 = reinterpret_cast< wxGrid * >(argp1);
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 result = (bool)(arg1)->CanDragGridSize();
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 {
14408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj = 0;
14418 wxGrid *arg1 = (wxGrid *) 0 ;
14419 bool arg2 = (bool) true ;
14420 void *argp1 = 0 ;
14421 int res1 = 0 ;
14422 bool val2 ;
14423 int ecode2 = 0 ;
14424 PyObject * obj0 = 0 ;
14425 PyObject * obj1 = 0 ;
14426 char * kwnames[] = {
14427 (char *) "self",(char *) "enable", NULL
14428 };
14429
14430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14432 if (!SWIG_IsOK(res1)) {
14433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14434 }
14435 arg1 = reinterpret_cast< wxGrid * >(argp1);
14436 if (obj1) {
14437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14438 if (!SWIG_IsOK(ecode2)) {
14439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14440 }
14441 arg2 = static_cast< bool >(val2);
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 (arg1)->EnableDragCell(arg2);
14446 wxPyEndAllowThreads(__tstate);
14447 if (PyErr_Occurred()) SWIG_fail;
14448 }
14449 resultobj = SWIG_Py_Void();
14450 return resultobj;
14451 fail:
14452 return NULL;
14453 }
14454
14455
14456 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14457 PyObject *resultobj = 0;
14458 wxGrid *arg1 = (wxGrid *) 0 ;
14459 void *argp1 = 0 ;
14460 int res1 = 0 ;
14461 PyObject *swig_obj[1] ;
14462
14463 if (!args) SWIG_fail;
14464 swig_obj[0] = args;
14465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14466 if (!SWIG_IsOK(res1)) {
14467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14468 }
14469 arg1 = reinterpret_cast< wxGrid * >(argp1);
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 (arg1)->DisableDragCell();
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = SWIG_Py_Void();
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14484 PyObject *resultobj = 0;
14485 wxGrid *arg1 = (wxGrid *) 0 ;
14486 bool result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 PyObject *swig_obj[1] ;
14490
14491 if (!args) SWIG_fail;
14492 swig_obj[0] = args;
14493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14494 if (!SWIG_IsOK(res1)) {
14495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14496 }
14497 arg1 = reinterpret_cast< wxGrid * >(argp1);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = (bool)(arg1)->CanDragCell();
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 {
14505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14506 }
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj = 0;
14515 wxGrid *arg1 = (wxGrid *) 0 ;
14516 int arg2 ;
14517 int arg3 ;
14518 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14519 void *argp1 = 0 ;
14520 int res1 = 0 ;
14521 int val2 ;
14522 int ecode2 = 0 ;
14523 int val3 ;
14524 int ecode3 = 0 ;
14525 void *argp4 = 0 ;
14526 int res4 = 0 ;
14527 PyObject * obj0 = 0 ;
14528 PyObject * obj1 = 0 ;
14529 PyObject * obj2 = 0 ;
14530 PyObject * obj3 = 0 ;
14531 char * kwnames[] = {
14532 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14533 };
14534
14535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14539 }
14540 arg1 = reinterpret_cast< wxGrid * >(argp1);
14541 ecode2 = SWIG_AsVal_int(obj1, &val2);
14542 if (!SWIG_IsOK(ecode2)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14544 }
14545 arg2 = static_cast< int >(val2);
14546 ecode3 = SWIG_AsVal_int(obj2, &val3);
14547 if (!SWIG_IsOK(ecode3)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14549 }
14550 arg3 = static_cast< int >(val3);
14551 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14552 if (!SWIG_IsOK(res4)) {
14553 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14554 }
14555 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 (arg1)->SetAttr(arg2,arg3,arg4);
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_Py_Void();
14563 return resultobj;
14564 fail:
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14570 PyObject *resultobj = 0;
14571 wxGrid *arg1 = (wxGrid *) 0 ;
14572 int arg2 ;
14573 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14574 void *argp1 = 0 ;
14575 int res1 = 0 ;
14576 int val2 ;
14577 int ecode2 = 0 ;
14578 void *argp3 = 0 ;
14579 int res3 = 0 ;
14580 PyObject * obj0 = 0 ;
14581 PyObject * obj1 = 0 ;
14582 PyObject * obj2 = 0 ;
14583 char * kwnames[] = {
14584 (char *) "self",(char *) "row",(char *) "attr", NULL
14585 };
14586
14587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14589 if (!SWIG_IsOK(res1)) {
14590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14591 }
14592 arg1 = reinterpret_cast< wxGrid * >(argp1);
14593 ecode2 = SWIG_AsVal_int(obj1, &val2);
14594 if (!SWIG_IsOK(ecode2)) {
14595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14596 }
14597 arg2 = static_cast< int >(val2);
14598 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14599 if (!SWIG_IsOK(res3)) {
14600 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14601 }
14602 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 (arg1)->SetRowAttr(arg2,arg3);
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 resultobj = SWIG_Py_Void();
14610 return resultobj;
14611 fail:
14612 return NULL;
14613 }
14614
14615
14616 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj = 0;
14618 wxGrid *arg1 = (wxGrid *) 0 ;
14619 int arg2 ;
14620 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14621 void *argp1 = 0 ;
14622 int res1 = 0 ;
14623 int val2 ;
14624 int ecode2 = 0 ;
14625 void *argp3 = 0 ;
14626 int res3 = 0 ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 PyObject * obj2 = 0 ;
14630 char * kwnames[] = {
14631 (char *) "self",(char *) "col",(char *) "attr", NULL
14632 };
14633
14634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14638 }
14639 arg1 = reinterpret_cast< wxGrid * >(argp1);
14640 ecode2 = SWIG_AsVal_int(obj1, &val2);
14641 if (!SWIG_IsOK(ecode2)) {
14642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14643 }
14644 arg2 = static_cast< int >(val2);
14645 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14646 if (!SWIG_IsOK(res3)) {
14647 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14648 }
14649 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14650 {
14651 PyThreadState* __tstate = wxPyBeginAllowThreads();
14652 (arg1)->SetColAttr(arg2,arg3);
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 resultobj = SWIG_Py_Void();
14657 return resultobj;
14658 fail:
14659 return NULL;
14660 }
14661
14662
14663 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14664 PyObject *resultobj = 0;
14665 wxGrid *arg1 = (wxGrid *) 0 ;
14666 int arg2 ;
14667 int arg3 ;
14668 wxGridCellAttr *result = 0 ;
14669 void *argp1 = 0 ;
14670 int res1 = 0 ;
14671 int val2 ;
14672 int ecode2 = 0 ;
14673 int val3 ;
14674 int ecode3 = 0 ;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 PyObject * obj2 = 0 ;
14678 char * kwnames[] = {
14679 (char *) "self",(char *) "row",(char *) "col", NULL
14680 };
14681
14682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14686 }
14687 arg1 = reinterpret_cast< wxGrid * >(argp1);
14688 ecode2 = SWIG_AsVal_int(obj1, &val2);
14689 if (!SWIG_IsOK(ecode2)) {
14690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14691 }
14692 arg2 = static_cast< int >(val2);
14693 ecode3 = SWIG_AsVal_int(obj2, &val3);
14694 if (!SWIG_IsOK(ecode3)) {
14695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14696 }
14697 arg3 = static_cast< int >(val3);
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 {
14705 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14706 }
14707 return resultobj;
14708 fail:
14709 return NULL;
14710 }
14711
14712
14713 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14714 PyObject *resultobj = 0;
14715 wxGrid *arg1 = (wxGrid *) 0 ;
14716 int arg2 ;
14717 void *argp1 = 0 ;
14718 int res1 = 0 ;
14719 int val2 ;
14720 int ecode2 = 0 ;
14721 PyObject * obj0 = 0 ;
14722 PyObject * obj1 = 0 ;
14723 char * kwnames[] = {
14724 (char *) "self",(char *) "col", NULL
14725 };
14726
14727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14729 if (!SWIG_IsOK(res1)) {
14730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14731 }
14732 arg1 = reinterpret_cast< wxGrid * >(argp1);
14733 ecode2 = SWIG_AsVal_int(obj1, &val2);
14734 if (!SWIG_IsOK(ecode2)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14736 }
14737 arg2 = static_cast< int >(val2);
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 (arg1)->SetColFormatBool(arg2);
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_Py_Void();
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj = 0;
14753 wxGrid *arg1 = (wxGrid *) 0 ;
14754 int arg2 ;
14755 void *argp1 = 0 ;
14756 int res1 = 0 ;
14757 int val2 ;
14758 int ecode2 = 0 ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 char * kwnames[] = {
14762 (char *) "self",(char *) "col", NULL
14763 };
14764
14765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14769 }
14770 arg1 = reinterpret_cast< wxGrid * >(argp1);
14771 ecode2 = SWIG_AsVal_int(obj1, &val2);
14772 if (!SWIG_IsOK(ecode2)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14774 }
14775 arg2 = static_cast< int >(val2);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 (arg1)->SetColFormatNumber(arg2);
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 resultobj = SWIG_Py_Void();
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj = 0;
14791 wxGrid *arg1 = (wxGrid *) 0 ;
14792 int arg2 ;
14793 int arg3 = (int) -1 ;
14794 int arg4 = (int) -1 ;
14795 void *argp1 = 0 ;
14796 int res1 = 0 ;
14797 int val2 ;
14798 int ecode2 = 0 ;
14799 int val3 ;
14800 int ecode3 = 0 ;
14801 int val4 ;
14802 int ecode4 = 0 ;
14803 PyObject * obj0 = 0 ;
14804 PyObject * obj1 = 0 ;
14805 PyObject * obj2 = 0 ;
14806 PyObject * obj3 = 0 ;
14807 char * kwnames[] = {
14808 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14809 };
14810
14811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14813 if (!SWIG_IsOK(res1)) {
14814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14815 }
14816 arg1 = reinterpret_cast< wxGrid * >(argp1);
14817 ecode2 = SWIG_AsVal_int(obj1, &val2);
14818 if (!SWIG_IsOK(ecode2)) {
14819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14820 }
14821 arg2 = static_cast< int >(val2);
14822 if (obj2) {
14823 ecode3 = SWIG_AsVal_int(obj2, &val3);
14824 if (!SWIG_IsOK(ecode3)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14826 }
14827 arg3 = static_cast< int >(val3);
14828 }
14829 if (obj3) {
14830 ecode4 = SWIG_AsVal_int(obj3, &val4);
14831 if (!SWIG_IsOK(ecode4)) {
14832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14833 }
14834 arg4 = static_cast< int >(val4);
14835 }
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 resultobj = SWIG_Py_Void();
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14850 PyObject *resultobj = 0;
14851 wxGrid *arg1 = (wxGrid *) 0 ;
14852 int arg2 ;
14853 wxString *arg3 = 0 ;
14854 void *argp1 = 0 ;
14855 int res1 = 0 ;
14856 int val2 ;
14857 int ecode2 = 0 ;
14858 bool temp3 = false ;
14859 PyObject * obj0 = 0 ;
14860 PyObject * obj1 = 0 ;
14861 PyObject * obj2 = 0 ;
14862 char * kwnames[] = {
14863 (char *) "self",(char *) "col",(char *) "typeName", NULL
14864 };
14865
14866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14868 if (!SWIG_IsOK(res1)) {
14869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14870 }
14871 arg1 = reinterpret_cast< wxGrid * >(argp1);
14872 ecode2 = SWIG_AsVal_int(obj1, &val2);
14873 if (!SWIG_IsOK(ecode2)) {
14874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14875 }
14876 arg2 = static_cast< int >(val2);
14877 {
14878 arg3 = wxString_in_helper(obj2);
14879 if (arg3 == NULL) SWIG_fail;
14880 temp3 = true;
14881 }
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 resultobj = SWIG_Py_Void();
14889 {
14890 if (temp3)
14891 delete arg3;
14892 }
14893 return resultobj;
14894 fail:
14895 {
14896 if (temp3)
14897 delete arg3;
14898 }
14899 return NULL;
14900 }
14901
14902
14903 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj = 0;
14905 wxGrid *arg1 = (wxGrid *) 0 ;
14906 bool arg2 = (bool) true ;
14907 void *argp1 = 0 ;
14908 int res1 = 0 ;
14909 bool val2 ;
14910 int ecode2 = 0 ;
14911 PyObject * obj0 = 0 ;
14912 PyObject * obj1 = 0 ;
14913 char * kwnames[] = {
14914 (char *) "self",(char *) "enable", NULL
14915 };
14916
14917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14919 if (!SWIG_IsOK(res1)) {
14920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14921 }
14922 arg1 = reinterpret_cast< wxGrid * >(argp1);
14923 if (obj1) {
14924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14925 if (!SWIG_IsOK(ecode2)) {
14926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14927 }
14928 arg2 = static_cast< bool >(val2);
14929 }
14930 {
14931 PyThreadState* __tstate = wxPyBeginAllowThreads();
14932 (arg1)->EnableGridLines(arg2);
14933 wxPyEndAllowThreads(__tstate);
14934 if (PyErr_Occurred()) SWIG_fail;
14935 }
14936 resultobj = SWIG_Py_Void();
14937 return resultobj;
14938 fail:
14939 return NULL;
14940 }
14941
14942
14943 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14944 PyObject *resultobj = 0;
14945 wxGrid *arg1 = (wxGrid *) 0 ;
14946 bool result;
14947 void *argp1 = 0 ;
14948 int res1 = 0 ;
14949 PyObject *swig_obj[1] ;
14950
14951 if (!args) SWIG_fail;
14952 swig_obj[0] = args;
14953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14954 if (!SWIG_IsOK(res1)) {
14955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14956 }
14957 arg1 = reinterpret_cast< wxGrid * >(argp1);
14958 {
14959 PyThreadState* __tstate = wxPyBeginAllowThreads();
14960 result = (bool)(arg1)->GridLinesEnabled();
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 {
14965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14966 }
14967 return resultobj;
14968 fail:
14969 return NULL;
14970 }
14971
14972
14973 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14974 PyObject *resultobj = 0;
14975 wxGrid *arg1 = (wxGrid *) 0 ;
14976 int result;
14977 void *argp1 = 0 ;
14978 int res1 = 0 ;
14979 PyObject *swig_obj[1] ;
14980
14981 if (!args) SWIG_fail;
14982 swig_obj[0] = args;
14983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14984 if (!SWIG_IsOK(res1)) {
14985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14986 }
14987 arg1 = reinterpret_cast< wxGrid * >(argp1);
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (int)(arg1)->GetDefaultRowSize();
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 resultobj = SWIG_From_int(static_cast< int >(result));
14995 return resultobj;
14996 fail:
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxGrid *arg1 = (wxGrid *) 0 ;
15004 int arg2 ;
15005 int result;
15006 void *argp1 = 0 ;
15007 int res1 = 0 ;
15008 int val2 ;
15009 int ecode2 = 0 ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 char * kwnames[] = {
15013 (char *) "self",(char *) "row", NULL
15014 };
15015
15016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15018 if (!SWIG_IsOK(res1)) {
15019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15020 }
15021 arg1 = reinterpret_cast< wxGrid * >(argp1);
15022 ecode2 = SWIG_AsVal_int(obj1, &val2);
15023 if (!SWIG_IsOK(ecode2)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15025 }
15026 arg2 = static_cast< int >(val2);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (int)(arg1)->GetRowSize(arg2);
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxGrid *arg1 = (wxGrid *) 0 ;
15043 int result;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 PyObject *swig_obj[1] ;
15047
15048 if (!args) SWIG_fail;
15049 swig_obj[0] = args;
15050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15051 if (!SWIG_IsOK(res1)) {
15052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15053 }
15054 arg1 = reinterpret_cast< wxGrid * >(argp1);
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (int)(arg1)->GetDefaultColSize();
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 resultobj = SWIG_From_int(static_cast< int >(result));
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj = 0;
15070 wxGrid *arg1 = (wxGrid *) 0 ;
15071 int arg2 ;
15072 int result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 int val2 ;
15076 int ecode2 = 0 ;
15077 PyObject * obj0 = 0 ;
15078 PyObject * obj1 = 0 ;
15079 char * kwnames[] = {
15080 (char *) "self",(char *) "col", NULL
15081 };
15082
15083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15087 }
15088 arg1 = reinterpret_cast< wxGrid * >(argp1);
15089 ecode2 = SWIG_AsVal_int(obj1, &val2);
15090 if (!SWIG_IsOK(ecode2)) {
15091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15092 }
15093 arg2 = static_cast< int >(val2);
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = (int)(arg1)->GetColSize(arg2);
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_From_int(static_cast< int >(result));
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15108 PyObject *resultobj = 0;
15109 wxGrid *arg1 = (wxGrid *) 0 ;
15110 wxColour result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 PyObject *swig_obj[1] ;
15114
15115 if (!args) SWIG_fail;
15116 swig_obj[0] = args;
15117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15118 if (!SWIG_IsOK(res1)) {
15119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15120 }
15121 arg1 = reinterpret_cast< wxGrid * >(argp1);
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (arg1)->GetDefaultCellBackgroundColour();
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxGrid *arg1 = (wxGrid *) 0 ;
15138 int arg2 ;
15139 int arg3 ;
15140 wxColour result;
15141 void *argp1 = 0 ;
15142 int res1 = 0 ;
15143 int val2 ;
15144 int ecode2 = 0 ;
15145 int val3 ;
15146 int ecode3 = 0 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 PyObject * obj2 = 0 ;
15150 char * kwnames[] = {
15151 (char *) "self",(char *) "row",(char *) "col", NULL
15152 };
15153
15154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15158 }
15159 arg1 = reinterpret_cast< wxGrid * >(argp1);
15160 ecode2 = SWIG_AsVal_int(obj1, &val2);
15161 if (!SWIG_IsOK(ecode2)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15163 }
15164 arg2 = static_cast< int >(val2);
15165 ecode3 = SWIG_AsVal_int(obj2, &val3);
15166 if (!SWIG_IsOK(ecode3)) {
15167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15168 }
15169 arg3 = static_cast< int >(val3);
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15184 PyObject *resultobj = 0;
15185 wxGrid *arg1 = (wxGrid *) 0 ;
15186 wxColour result;
15187 void *argp1 = 0 ;
15188 int res1 = 0 ;
15189 PyObject *swig_obj[1] ;
15190
15191 if (!args) SWIG_fail;
15192 swig_obj[0] = args;
15193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15194 if (!SWIG_IsOK(res1)) {
15195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15196 }
15197 arg1 = reinterpret_cast< wxGrid * >(argp1);
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (arg1)->GetDefaultCellTextColour();
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15205 return resultobj;
15206 fail:
15207 return NULL;
15208 }
15209
15210
15211 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15212 PyObject *resultobj = 0;
15213 wxGrid *arg1 = (wxGrid *) 0 ;
15214 int arg2 ;
15215 int arg3 ;
15216 wxColour result;
15217 void *argp1 = 0 ;
15218 int res1 = 0 ;
15219 int val2 ;
15220 int ecode2 = 0 ;
15221 int val3 ;
15222 int ecode3 = 0 ;
15223 PyObject * obj0 = 0 ;
15224 PyObject * obj1 = 0 ;
15225 PyObject * obj2 = 0 ;
15226 char * kwnames[] = {
15227 (char *) "self",(char *) "row",(char *) "col", NULL
15228 };
15229
15230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15232 if (!SWIG_IsOK(res1)) {
15233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15234 }
15235 arg1 = reinterpret_cast< wxGrid * >(argp1);
15236 ecode2 = SWIG_AsVal_int(obj1, &val2);
15237 if (!SWIG_IsOK(ecode2)) {
15238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15239 }
15240 arg2 = static_cast< int >(val2);
15241 ecode3 = SWIG_AsVal_int(obj2, &val3);
15242 if (!SWIG_IsOK(ecode3)) {
15243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15244 }
15245 arg3 = static_cast< int >(val3);
15246 {
15247 PyThreadState* __tstate = wxPyBeginAllowThreads();
15248 result = (arg1)->GetCellTextColour(arg2,arg3);
15249 wxPyEndAllowThreads(__tstate);
15250 if (PyErr_Occurred()) SWIG_fail;
15251 }
15252 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15253 return resultobj;
15254 fail:
15255 return NULL;
15256 }
15257
15258
15259 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15260 PyObject *resultobj = 0;
15261 wxGrid *arg1 = (wxGrid *) 0 ;
15262 wxFont result;
15263 void *argp1 = 0 ;
15264 int res1 = 0 ;
15265 PyObject *swig_obj[1] ;
15266
15267 if (!args) SWIG_fail;
15268 swig_obj[0] = args;
15269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15270 if (!SWIG_IsOK(res1)) {
15271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15272 }
15273 arg1 = reinterpret_cast< wxGrid * >(argp1);
15274 {
15275 PyThreadState* __tstate = wxPyBeginAllowThreads();
15276 result = (arg1)->GetDefaultCellFont();
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15288 PyObject *resultobj = 0;
15289 wxGrid *arg1 = (wxGrid *) 0 ;
15290 int arg2 ;
15291 int arg3 ;
15292 wxFont result;
15293 void *argp1 = 0 ;
15294 int res1 = 0 ;
15295 int val2 ;
15296 int ecode2 = 0 ;
15297 int val3 ;
15298 int ecode3 = 0 ;
15299 PyObject * obj0 = 0 ;
15300 PyObject * obj1 = 0 ;
15301 PyObject * obj2 = 0 ;
15302 char * kwnames[] = {
15303 (char *) "self",(char *) "row",(char *) "col", NULL
15304 };
15305
15306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15308 if (!SWIG_IsOK(res1)) {
15309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15310 }
15311 arg1 = reinterpret_cast< wxGrid * >(argp1);
15312 ecode2 = SWIG_AsVal_int(obj1, &val2);
15313 if (!SWIG_IsOK(ecode2)) {
15314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15315 }
15316 arg2 = static_cast< int >(val2);
15317 ecode3 = SWIG_AsVal_int(obj2, &val3);
15318 if (!SWIG_IsOK(ecode3)) {
15319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15320 }
15321 arg3 = static_cast< int >(val3);
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 result = (arg1)->GetCellFont(arg2,arg3);
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxGrid *arg1 = (wxGrid *) 0 ;
15338 int *arg2 = (int *) 0 ;
15339 int *arg3 = (int *) 0 ;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 int temp2 ;
15343 int res2 = SWIG_TMPOBJ ;
15344 int temp3 ;
15345 int res3 = SWIG_TMPOBJ ;
15346 PyObject *swig_obj[1] ;
15347
15348 arg2 = &temp2;
15349 arg3 = &temp3;
15350 if (!args) SWIG_fail;
15351 swig_obj[0] = args;
15352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15353 if (!SWIG_IsOK(res1)) {
15354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15355 }
15356 arg1 = reinterpret_cast< wxGrid * >(argp1);
15357 {
15358 PyThreadState* __tstate = wxPyBeginAllowThreads();
15359 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 resultobj = SWIG_Py_Void();
15364 if (SWIG_IsTmpObj(res2)) {
15365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15366 } else {
15367 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15369 }
15370 if (SWIG_IsTmpObj(res3)) {
15371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15372 } else {
15373 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15375 }
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj = 0;
15384 wxGrid *arg1 = (wxGrid *) 0 ;
15385 int arg2 ;
15386 int arg3 ;
15387 int *arg4 = (int *) 0 ;
15388 int *arg5 = (int *) 0 ;
15389 void *argp1 = 0 ;
15390 int res1 = 0 ;
15391 int val2 ;
15392 int ecode2 = 0 ;
15393 int val3 ;
15394 int ecode3 = 0 ;
15395 int temp4 ;
15396 int res4 = SWIG_TMPOBJ ;
15397 int temp5 ;
15398 int res5 = SWIG_TMPOBJ ;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 PyObject * obj2 = 0 ;
15402 char * kwnames[] = {
15403 (char *) "self",(char *) "row",(char *) "col", NULL
15404 };
15405
15406 arg4 = &temp4;
15407 arg5 = &temp5;
15408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15412 }
15413 arg1 = reinterpret_cast< wxGrid * >(argp1);
15414 ecode2 = SWIG_AsVal_int(obj1, &val2);
15415 if (!SWIG_IsOK(ecode2)) {
15416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15417 }
15418 arg2 = static_cast< int >(val2);
15419 ecode3 = SWIG_AsVal_int(obj2, &val3);
15420 if (!SWIG_IsOK(ecode3)) {
15421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15422 }
15423 arg3 = static_cast< int >(val3);
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = SWIG_Py_Void();
15431 if (SWIG_IsTmpObj(res4)) {
15432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15433 } else {
15434 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15436 }
15437 if (SWIG_IsTmpObj(res5)) {
15438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15439 } else {
15440 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15442 }
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15450 PyObject *resultobj = 0;
15451 wxGrid *arg1 = (wxGrid *) 0 ;
15452 bool result;
15453 void *argp1 = 0 ;
15454 int res1 = 0 ;
15455 PyObject *swig_obj[1] ;
15456
15457 if (!args) SWIG_fail;
15458 swig_obj[0] = args;
15459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15460 if (!SWIG_IsOK(res1)) {
15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15462 }
15463 arg1 = reinterpret_cast< wxGrid * >(argp1);
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 result = (bool)(arg1)->GetDefaultCellOverflow();
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 {
15471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15472 }
15473 return resultobj;
15474 fail:
15475 return NULL;
15476 }
15477
15478
15479 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15480 PyObject *resultobj = 0;
15481 wxGrid *arg1 = (wxGrid *) 0 ;
15482 int arg2 ;
15483 int arg3 ;
15484 bool result;
15485 void *argp1 = 0 ;
15486 int res1 = 0 ;
15487 int val2 ;
15488 int ecode2 = 0 ;
15489 int val3 ;
15490 int ecode3 = 0 ;
15491 PyObject * obj0 = 0 ;
15492 PyObject * obj1 = 0 ;
15493 PyObject * obj2 = 0 ;
15494 char * kwnames[] = {
15495 (char *) "self",(char *) "row",(char *) "col", NULL
15496 };
15497
15498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15500 if (!SWIG_IsOK(res1)) {
15501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15502 }
15503 arg1 = reinterpret_cast< wxGrid * >(argp1);
15504 ecode2 = SWIG_AsVal_int(obj1, &val2);
15505 if (!SWIG_IsOK(ecode2)) {
15506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15507 }
15508 arg2 = static_cast< int >(val2);
15509 ecode3 = SWIG_AsVal_int(obj2, &val3);
15510 if (!SWIG_IsOK(ecode3)) {
15511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15512 }
15513 arg3 = static_cast< int >(val3);
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15517 wxPyEndAllowThreads(__tstate);
15518 if (PyErr_Occurred()) SWIG_fail;
15519 }
15520 {
15521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15522 }
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj = 0;
15531 wxGrid *arg1 = (wxGrid *) 0 ;
15532 int arg2 ;
15533 int arg3 ;
15534 int *arg4 = (int *) 0 ;
15535 int *arg5 = (int *) 0 ;
15536 void *argp1 = 0 ;
15537 int res1 = 0 ;
15538 int val2 ;
15539 int ecode2 = 0 ;
15540 int val3 ;
15541 int ecode3 = 0 ;
15542 int temp4 ;
15543 int res4 = SWIG_TMPOBJ ;
15544 int temp5 ;
15545 int res5 = SWIG_TMPOBJ ;
15546 PyObject * obj0 = 0 ;
15547 PyObject * obj1 = 0 ;
15548 PyObject * obj2 = 0 ;
15549 char * kwnames[] = {
15550 (char *) "self",(char *) "row",(char *) "col", NULL
15551 };
15552
15553 arg4 = &temp4;
15554 arg5 = &temp5;
15555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15557 if (!SWIG_IsOK(res1)) {
15558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15559 }
15560 arg1 = reinterpret_cast< wxGrid * >(argp1);
15561 ecode2 = SWIG_AsVal_int(obj1, &val2);
15562 if (!SWIG_IsOK(ecode2)) {
15563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15564 }
15565 arg2 = static_cast< int >(val2);
15566 ecode3 = SWIG_AsVal_int(obj2, &val3);
15567 if (!SWIG_IsOK(ecode3)) {
15568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15569 }
15570 arg3 = static_cast< int >(val3);
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 resultobj = SWIG_Py_Void();
15578 if (SWIG_IsTmpObj(res4)) {
15579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15580 } else {
15581 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15583 }
15584 if (SWIG_IsTmpObj(res5)) {
15585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15586 } else {
15587 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15589 }
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15597 PyObject *resultobj = 0;
15598 wxGrid *arg1 = (wxGrid *) 0 ;
15599 int arg2 ;
15600 bool arg3 = (bool) false ;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 int val2 ;
15604 int ecode2 = 0 ;
15605 bool val3 ;
15606 int ecode3 = 0 ;
15607 PyObject * obj0 = 0 ;
15608 PyObject * obj1 = 0 ;
15609 PyObject * obj2 = 0 ;
15610 char * kwnames[] = {
15611 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15612 };
15613
15614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15618 }
15619 arg1 = reinterpret_cast< wxGrid * >(argp1);
15620 ecode2 = SWIG_AsVal_int(obj1, &val2);
15621 if (!SWIG_IsOK(ecode2)) {
15622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15623 }
15624 arg2 = static_cast< int >(val2);
15625 if (obj2) {
15626 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15627 if (!SWIG_IsOK(ecode3)) {
15628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15629 }
15630 arg3 = static_cast< bool >(val3);
15631 }
15632 {
15633 PyThreadState* __tstate = wxPyBeginAllowThreads();
15634 (arg1)->SetDefaultRowSize(arg2,arg3);
15635 wxPyEndAllowThreads(__tstate);
15636 if (PyErr_Occurred()) SWIG_fail;
15637 }
15638 resultobj = SWIG_Py_Void();
15639 return resultobj;
15640 fail:
15641 return NULL;
15642 }
15643
15644
15645 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj = 0;
15647 wxGrid *arg1 = (wxGrid *) 0 ;
15648 int arg2 ;
15649 int arg3 ;
15650 void *argp1 = 0 ;
15651 int res1 = 0 ;
15652 int val2 ;
15653 int ecode2 = 0 ;
15654 int val3 ;
15655 int ecode3 = 0 ;
15656 PyObject * obj0 = 0 ;
15657 PyObject * obj1 = 0 ;
15658 PyObject * obj2 = 0 ;
15659 char * kwnames[] = {
15660 (char *) "self",(char *) "row",(char *) "height", NULL
15661 };
15662
15663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15665 if (!SWIG_IsOK(res1)) {
15666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15667 }
15668 arg1 = reinterpret_cast< wxGrid * >(argp1);
15669 ecode2 = SWIG_AsVal_int(obj1, &val2);
15670 if (!SWIG_IsOK(ecode2)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15672 }
15673 arg2 = static_cast< int >(val2);
15674 ecode3 = SWIG_AsVal_int(obj2, &val3);
15675 if (!SWIG_IsOK(ecode3)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15677 }
15678 arg3 = static_cast< int >(val3);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 (arg1)->SetRowSize(arg2,arg3);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_Py_Void();
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15693 PyObject *resultobj = 0;
15694 wxGrid *arg1 = (wxGrid *) 0 ;
15695 int arg2 ;
15696 bool arg3 = (bool) false ;
15697 void *argp1 = 0 ;
15698 int res1 = 0 ;
15699 int val2 ;
15700 int ecode2 = 0 ;
15701 bool val3 ;
15702 int ecode3 = 0 ;
15703 PyObject * obj0 = 0 ;
15704 PyObject * obj1 = 0 ;
15705 PyObject * obj2 = 0 ;
15706 char * kwnames[] = {
15707 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15708 };
15709
15710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15714 }
15715 arg1 = reinterpret_cast< wxGrid * >(argp1);
15716 ecode2 = SWIG_AsVal_int(obj1, &val2);
15717 if (!SWIG_IsOK(ecode2)) {
15718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15719 }
15720 arg2 = static_cast< int >(val2);
15721 if (obj2) {
15722 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15723 if (!SWIG_IsOK(ecode3)) {
15724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15725 }
15726 arg3 = static_cast< bool >(val3);
15727 }
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 (arg1)->SetDefaultColSize(arg2,arg3);
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 resultobj = SWIG_Py_Void();
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15742 PyObject *resultobj = 0;
15743 wxGrid *arg1 = (wxGrid *) 0 ;
15744 int arg2 ;
15745 int arg3 ;
15746 void *argp1 = 0 ;
15747 int res1 = 0 ;
15748 int val2 ;
15749 int ecode2 = 0 ;
15750 int val3 ;
15751 int ecode3 = 0 ;
15752 PyObject * obj0 = 0 ;
15753 PyObject * obj1 = 0 ;
15754 PyObject * obj2 = 0 ;
15755 char * kwnames[] = {
15756 (char *) "self",(char *) "col",(char *) "width", NULL
15757 };
15758
15759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15761 if (!SWIG_IsOK(res1)) {
15762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15763 }
15764 arg1 = reinterpret_cast< wxGrid * >(argp1);
15765 ecode2 = SWIG_AsVal_int(obj1, &val2);
15766 if (!SWIG_IsOK(ecode2)) {
15767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15768 }
15769 arg2 = static_cast< int >(val2);
15770 ecode3 = SWIG_AsVal_int(obj2, &val3);
15771 if (!SWIG_IsOK(ecode3)) {
15772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15773 }
15774 arg3 = static_cast< int >(val3);
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 (arg1)->SetColSize(arg2,arg3);
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 resultobj = SWIG_Py_Void();
15782 return resultobj;
15783 fail:
15784 return NULL;
15785 }
15786
15787
15788 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15789 PyObject *resultobj = 0;
15790 wxGrid *arg1 = (wxGrid *) 0 ;
15791 int arg2 ;
15792 int result;
15793 void *argp1 = 0 ;
15794 int res1 = 0 ;
15795 int val2 ;
15796 int ecode2 = 0 ;
15797 PyObject * obj0 = 0 ;
15798 PyObject * obj1 = 0 ;
15799 char * kwnames[] = {
15800 (char *) "self",(char *) "colPos", NULL
15801 };
15802
15803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15805 if (!SWIG_IsOK(res1)) {
15806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15807 }
15808 arg1 = reinterpret_cast< wxGrid * >(argp1);
15809 ecode2 = SWIG_AsVal_int(obj1, &val2);
15810 if (!SWIG_IsOK(ecode2)) {
15811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15812 }
15813 arg2 = static_cast< int >(val2);
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15817 wxPyEndAllowThreads(__tstate);
15818 if (PyErr_Occurred()) SWIG_fail;
15819 }
15820 resultobj = SWIG_From_int(static_cast< int >(result));
15821 return resultobj;
15822 fail:
15823 return NULL;
15824 }
15825
15826
15827 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15828 PyObject *resultobj = 0;
15829 wxGrid *arg1 = (wxGrid *) 0 ;
15830 int arg2 ;
15831 int arg3 ;
15832 void *argp1 = 0 ;
15833 int res1 = 0 ;
15834 int val2 ;
15835 int ecode2 = 0 ;
15836 int val3 ;
15837 int ecode3 = 0 ;
15838 PyObject * obj0 = 0 ;
15839 PyObject * obj1 = 0 ;
15840 PyObject * obj2 = 0 ;
15841 char * kwnames[] = {
15842 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15843 };
15844
15845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15849 }
15850 arg1 = reinterpret_cast< wxGrid * >(argp1);
15851 ecode2 = SWIG_AsVal_int(obj1, &val2);
15852 if (!SWIG_IsOK(ecode2)) {
15853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15854 }
15855 arg2 = static_cast< int >(val2);
15856 ecode3 = SWIG_AsVal_int(obj2, &val3);
15857 if (!SWIG_IsOK(ecode3)) {
15858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15859 }
15860 arg3 = static_cast< int >(val3);
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 (arg1)->SetColPos(arg2,arg3);
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 resultobj = SWIG_Py_Void();
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = 0;
15876 wxGrid *arg1 = (wxGrid *) 0 ;
15877 int arg2 ;
15878 int result;
15879 void *argp1 = 0 ;
15880 int res1 = 0 ;
15881 int val2 ;
15882 int ecode2 = 0 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "colID", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15893 }
15894 arg1 = reinterpret_cast< wxGrid * >(argp1);
15895 ecode2 = SWIG_AsVal_int(obj1, &val2);
15896 if (!SWIG_IsOK(ecode2)) {
15897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15898 }
15899 arg2 = static_cast< int >(val2);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_int(static_cast< int >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj = 0;
15915 wxGrid *arg1 = (wxGrid *) 0 ;
15916 int arg2 ;
15917 bool arg3 = (bool) true ;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 int val2 ;
15921 int ecode2 = 0 ;
15922 bool val3 ;
15923 int ecode3 = 0 ;
15924 PyObject * obj0 = 0 ;
15925 PyObject * obj1 = 0 ;
15926 PyObject * obj2 = 0 ;
15927 char * kwnames[] = {
15928 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15929 };
15930
15931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15935 }
15936 arg1 = reinterpret_cast< wxGrid * >(argp1);
15937 ecode2 = SWIG_AsVal_int(obj1, &val2);
15938 if (!SWIG_IsOK(ecode2)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15940 }
15941 arg2 = static_cast< int >(val2);
15942 if (obj2) {
15943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15944 if (!SWIG_IsOK(ecode3)) {
15945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15946 }
15947 arg3 = static_cast< bool >(val3);
15948 }
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 (arg1)->AutoSizeColumn(arg2,arg3);
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_Py_Void();
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15963 PyObject *resultobj = 0;
15964 wxGrid *arg1 = (wxGrid *) 0 ;
15965 int arg2 ;
15966 bool arg3 = (bool) true ;
15967 void *argp1 = 0 ;
15968 int res1 = 0 ;
15969 int val2 ;
15970 int ecode2 = 0 ;
15971 bool val3 ;
15972 int ecode3 = 0 ;
15973 PyObject * obj0 = 0 ;
15974 PyObject * obj1 = 0 ;
15975 PyObject * obj2 = 0 ;
15976 char * kwnames[] = {
15977 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15978 };
15979
15980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15982 if (!SWIG_IsOK(res1)) {
15983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15984 }
15985 arg1 = reinterpret_cast< wxGrid * >(argp1);
15986 ecode2 = SWIG_AsVal_int(obj1, &val2);
15987 if (!SWIG_IsOK(ecode2)) {
15988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15989 }
15990 arg2 = static_cast< int >(val2);
15991 if (obj2) {
15992 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15993 if (!SWIG_IsOK(ecode3)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15995 }
15996 arg3 = static_cast< bool >(val3);
15997 }
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 (arg1)->AutoSizeRow(arg2,arg3);
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 resultobj = SWIG_Py_Void();
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16012 PyObject *resultobj = 0;
16013 wxGrid *arg1 = (wxGrid *) 0 ;
16014 bool arg2 = (bool) true ;
16015 void *argp1 = 0 ;
16016 int res1 = 0 ;
16017 bool val2 ;
16018 int ecode2 = 0 ;
16019 PyObject * obj0 = 0 ;
16020 PyObject * obj1 = 0 ;
16021 char * kwnames[] = {
16022 (char *) "self",(char *) "setAsMin", NULL
16023 };
16024
16025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16027 if (!SWIG_IsOK(res1)) {
16028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16029 }
16030 arg1 = reinterpret_cast< wxGrid * >(argp1);
16031 if (obj1) {
16032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16033 if (!SWIG_IsOK(ecode2)) {
16034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16035 }
16036 arg2 = static_cast< bool >(val2);
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 (arg1)->AutoSizeColumns(arg2);
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 resultobj = SWIG_Py_Void();
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj = 0;
16053 wxGrid *arg1 = (wxGrid *) 0 ;
16054 bool arg2 = (bool) true ;
16055 void *argp1 = 0 ;
16056 int res1 = 0 ;
16057 bool val2 ;
16058 int ecode2 = 0 ;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "setAsMin", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16069 }
16070 arg1 = reinterpret_cast< wxGrid * >(argp1);
16071 if (obj1) {
16072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16073 if (!SWIG_IsOK(ecode2)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16075 }
16076 arg2 = static_cast< bool >(val2);
16077 }
16078 {
16079 PyThreadState* __tstate = wxPyBeginAllowThreads();
16080 (arg1)->AutoSizeRows(arg2);
16081 wxPyEndAllowThreads(__tstate);
16082 if (PyErr_Occurred()) SWIG_fail;
16083 }
16084 resultobj = SWIG_Py_Void();
16085 return resultobj;
16086 fail:
16087 return NULL;
16088 }
16089
16090
16091 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16092 PyObject *resultobj = 0;
16093 wxGrid *arg1 = (wxGrid *) 0 ;
16094 void *argp1 = 0 ;
16095 int res1 = 0 ;
16096 PyObject *swig_obj[1] ;
16097
16098 if (!args) SWIG_fail;
16099 swig_obj[0] = args;
16100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16103 }
16104 arg1 = reinterpret_cast< wxGrid * >(argp1);
16105 {
16106 PyThreadState* __tstate = wxPyBeginAllowThreads();
16107 (arg1)->AutoSize();
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_Py_Void();
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj = 0;
16120 wxGrid *arg1 = (wxGrid *) 0 ;
16121 int arg2 ;
16122 void *argp1 = 0 ;
16123 int res1 = 0 ;
16124 int val2 ;
16125 int ecode2 = 0 ;
16126 PyObject * obj0 = 0 ;
16127 PyObject * obj1 = 0 ;
16128 char * kwnames[] = {
16129 (char *) "self",(char *) "row", NULL
16130 };
16131
16132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16134 if (!SWIG_IsOK(res1)) {
16135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16136 }
16137 arg1 = reinterpret_cast< wxGrid * >(argp1);
16138 ecode2 = SWIG_AsVal_int(obj1, &val2);
16139 if (!SWIG_IsOK(ecode2)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16141 }
16142 arg2 = static_cast< int >(val2);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->AutoSizeRowLabelSize(arg2);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_Py_Void();
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = 0;
16158 wxGrid *arg1 = (wxGrid *) 0 ;
16159 int arg2 ;
16160 void *argp1 = 0 ;
16161 int res1 = 0 ;
16162 int val2 ;
16163 int ecode2 = 0 ;
16164 PyObject * obj0 = 0 ;
16165 PyObject * obj1 = 0 ;
16166 char * kwnames[] = {
16167 (char *) "self",(char *) "col", NULL
16168 };
16169
16170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16172 if (!SWIG_IsOK(res1)) {
16173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16174 }
16175 arg1 = reinterpret_cast< wxGrid * >(argp1);
16176 ecode2 = SWIG_AsVal_int(obj1, &val2);
16177 if (!SWIG_IsOK(ecode2)) {
16178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16179 }
16180 arg2 = static_cast< int >(val2);
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 (arg1)->AutoSizeColLabelSize(arg2);
16184 wxPyEndAllowThreads(__tstate);
16185 if (PyErr_Occurred()) SWIG_fail;
16186 }
16187 resultobj = SWIG_Py_Void();
16188 return resultobj;
16189 fail:
16190 return NULL;
16191 }
16192
16193
16194 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16195 PyObject *resultobj = 0;
16196 wxGrid *arg1 = (wxGrid *) 0 ;
16197 int arg2 ;
16198 int arg3 ;
16199 void *argp1 = 0 ;
16200 int res1 = 0 ;
16201 int val2 ;
16202 int ecode2 = 0 ;
16203 int val3 ;
16204 int ecode3 = 0 ;
16205 PyObject * obj0 = 0 ;
16206 PyObject * obj1 = 0 ;
16207 PyObject * obj2 = 0 ;
16208 char * kwnames[] = {
16209 (char *) "self",(char *) "col",(char *) "width", NULL
16210 };
16211
16212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16214 if (!SWIG_IsOK(res1)) {
16215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16216 }
16217 arg1 = reinterpret_cast< wxGrid * >(argp1);
16218 ecode2 = SWIG_AsVal_int(obj1, &val2);
16219 if (!SWIG_IsOK(ecode2)) {
16220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16221 }
16222 arg2 = static_cast< int >(val2);
16223 ecode3 = SWIG_AsVal_int(obj2, &val3);
16224 if (!SWIG_IsOK(ecode3)) {
16225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16226 }
16227 arg3 = static_cast< int >(val3);
16228 {
16229 PyThreadState* __tstate = wxPyBeginAllowThreads();
16230 (arg1)->SetColMinimalWidth(arg2,arg3);
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 resultobj = SWIG_Py_Void();
16235 return resultobj;
16236 fail:
16237 return NULL;
16238 }
16239
16240
16241 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16242 PyObject *resultobj = 0;
16243 wxGrid *arg1 = (wxGrid *) 0 ;
16244 int arg2 ;
16245 int arg3 ;
16246 void *argp1 = 0 ;
16247 int res1 = 0 ;
16248 int val2 ;
16249 int ecode2 = 0 ;
16250 int val3 ;
16251 int ecode3 = 0 ;
16252 PyObject * obj0 = 0 ;
16253 PyObject * obj1 = 0 ;
16254 PyObject * obj2 = 0 ;
16255 char * kwnames[] = {
16256 (char *) "self",(char *) "row",(char *) "width", NULL
16257 };
16258
16259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16261 if (!SWIG_IsOK(res1)) {
16262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16263 }
16264 arg1 = reinterpret_cast< wxGrid * >(argp1);
16265 ecode2 = SWIG_AsVal_int(obj1, &val2);
16266 if (!SWIG_IsOK(ecode2)) {
16267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16268 }
16269 arg2 = static_cast< int >(val2);
16270 ecode3 = SWIG_AsVal_int(obj2, &val3);
16271 if (!SWIG_IsOK(ecode3)) {
16272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16273 }
16274 arg3 = static_cast< int >(val3);
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 (arg1)->SetRowMinimalHeight(arg2,arg3);
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 resultobj = SWIG_Py_Void();
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16289 PyObject *resultobj = 0;
16290 wxGrid *arg1 = (wxGrid *) 0 ;
16291 int arg2 ;
16292 void *argp1 = 0 ;
16293 int res1 = 0 ;
16294 int val2 ;
16295 int ecode2 = 0 ;
16296 PyObject * obj0 = 0 ;
16297 PyObject * obj1 = 0 ;
16298 char * kwnames[] = {
16299 (char *) "self",(char *) "width", NULL
16300 };
16301
16302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16306 }
16307 arg1 = reinterpret_cast< wxGrid * >(argp1);
16308 ecode2 = SWIG_AsVal_int(obj1, &val2);
16309 if (!SWIG_IsOK(ecode2)) {
16310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16311 }
16312 arg2 = static_cast< int >(val2);
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 (arg1)->SetColMinimalAcceptableWidth(arg2);
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 resultobj = SWIG_Py_Void();
16320 return resultobj;
16321 fail:
16322 return NULL;
16323 }
16324
16325
16326 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16327 PyObject *resultobj = 0;
16328 wxGrid *arg1 = (wxGrid *) 0 ;
16329 int arg2 ;
16330 void *argp1 = 0 ;
16331 int res1 = 0 ;
16332 int val2 ;
16333 int ecode2 = 0 ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "width", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16344 }
16345 arg1 = reinterpret_cast< wxGrid * >(argp1);
16346 ecode2 = SWIG_AsVal_int(obj1, &val2);
16347 if (!SWIG_IsOK(ecode2)) {
16348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16349 }
16350 arg2 = static_cast< int >(val2);
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_Py_Void();
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16365 PyObject *resultobj = 0;
16366 wxGrid *arg1 = (wxGrid *) 0 ;
16367 int result;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 PyObject *swig_obj[1] ;
16371
16372 if (!args) SWIG_fail;
16373 swig_obj[0] = args;
16374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16375 if (!SWIG_IsOK(res1)) {
16376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16377 }
16378 arg1 = reinterpret_cast< wxGrid * >(argp1);
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 resultobj = SWIG_From_int(static_cast< int >(result));
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16393 PyObject *resultobj = 0;
16394 wxGrid *arg1 = (wxGrid *) 0 ;
16395 int result;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 PyObject *swig_obj[1] ;
16399
16400 if (!args) SWIG_fail;
16401 swig_obj[0] = args;
16402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16405 }
16406 arg1 = reinterpret_cast< wxGrid * >(argp1);
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16410 wxPyEndAllowThreads(__tstate);
16411 if (PyErr_Occurred()) SWIG_fail;
16412 }
16413 resultobj = SWIG_From_int(static_cast< int >(result));
16414 return resultobj;
16415 fail:
16416 return NULL;
16417 }
16418
16419
16420 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16421 PyObject *resultobj = 0;
16422 wxGrid *arg1 = (wxGrid *) 0 ;
16423 wxColour *arg2 = 0 ;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 wxColour temp2 ;
16427 PyObject * obj0 = 0 ;
16428 PyObject * obj1 = 0 ;
16429 char * kwnames[] = {
16430 (char *) "self",(char *)"arg2", NULL
16431 };
16432
16433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16435 if (!SWIG_IsOK(res1)) {
16436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16437 }
16438 arg1 = reinterpret_cast< wxGrid * >(argp1);
16439 {
16440 arg2 = &temp2;
16441 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16442 }
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_Py_Void();
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj = 0;
16458 wxGrid *arg1 = (wxGrid *) 0 ;
16459 int arg2 ;
16460 int arg3 ;
16461 wxColour *arg4 = 0 ;
16462 void *argp1 = 0 ;
16463 int res1 = 0 ;
16464 int val2 ;
16465 int ecode2 = 0 ;
16466 int val3 ;
16467 int ecode3 = 0 ;
16468 wxColour temp4 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 PyObject * obj2 = 0 ;
16472 PyObject * obj3 = 0 ;
16473 char * kwnames[] = {
16474 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16475 };
16476
16477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16479 if (!SWIG_IsOK(res1)) {
16480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16481 }
16482 arg1 = reinterpret_cast< wxGrid * >(argp1);
16483 ecode2 = SWIG_AsVal_int(obj1, &val2);
16484 if (!SWIG_IsOK(ecode2)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16486 }
16487 arg2 = static_cast< int >(val2);
16488 ecode3 = SWIG_AsVal_int(obj2, &val3);
16489 if (!SWIG_IsOK(ecode3)) {
16490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16491 }
16492 arg3 = static_cast< int >(val3);
16493 {
16494 arg4 = &temp4;
16495 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_Py_Void();
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxGrid *arg1 = (wxGrid *) 0 ;
16513 wxColour *arg2 = 0 ;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 wxColour temp2 ;
16517 PyObject * obj0 = 0 ;
16518 PyObject * obj1 = 0 ;
16519 char * kwnames[] = {
16520 (char *) "self",(char *)"arg2", NULL
16521 };
16522
16523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16525 if (!SWIG_IsOK(res1)) {
16526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16527 }
16528 arg1 = reinterpret_cast< wxGrid * >(argp1);
16529 {
16530 arg2 = &temp2;
16531 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16532 }
16533 {
16534 PyThreadState* __tstate = wxPyBeginAllowThreads();
16535 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 resultobj = SWIG_Py_Void();
16540 return resultobj;
16541 fail:
16542 return NULL;
16543 }
16544
16545
16546 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16547 PyObject *resultobj = 0;
16548 wxGrid *arg1 = (wxGrid *) 0 ;
16549 int arg2 ;
16550 int arg3 ;
16551 wxColour *arg4 = 0 ;
16552 void *argp1 = 0 ;
16553 int res1 = 0 ;
16554 int val2 ;
16555 int ecode2 = 0 ;
16556 int val3 ;
16557 int ecode3 = 0 ;
16558 wxColour temp4 ;
16559 PyObject * obj0 = 0 ;
16560 PyObject * obj1 = 0 ;
16561 PyObject * obj2 = 0 ;
16562 PyObject * obj3 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16571 }
16572 arg1 = reinterpret_cast< wxGrid * >(argp1);
16573 ecode2 = SWIG_AsVal_int(obj1, &val2);
16574 if (!SWIG_IsOK(ecode2)) {
16575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16576 }
16577 arg2 = static_cast< int >(val2);
16578 ecode3 = SWIG_AsVal_int(obj2, &val3);
16579 if (!SWIG_IsOK(ecode3)) {
16580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16581 }
16582 arg3 = static_cast< int >(val3);
16583 {
16584 arg4 = &temp4;
16585 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16586 }
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = SWIG_Py_Void();
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = 0;
16602 wxGrid *arg1 = (wxGrid *) 0 ;
16603 wxFont *arg2 = 0 ;
16604 void *argp1 = 0 ;
16605 int res1 = 0 ;
16606 void *argp2 = 0 ;
16607 int res2 = 0 ;
16608 PyObject * obj0 = 0 ;
16609 PyObject * obj1 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *)"arg2", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16616 if (!SWIG_IsOK(res1)) {
16617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16618 }
16619 arg1 = reinterpret_cast< wxGrid * >(argp1);
16620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16621 if (!SWIG_IsOK(res2)) {
16622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16623 }
16624 if (!argp2) {
16625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16626 }
16627 arg2 = reinterpret_cast< wxFont * >(argp2);
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 resultobj = SWIG_Py_Void();
16635 return resultobj;
16636 fail:
16637 return NULL;
16638 }
16639
16640
16641 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16642 PyObject *resultobj = 0;
16643 wxGrid *arg1 = (wxGrid *) 0 ;
16644 int arg2 ;
16645 int arg3 ;
16646 wxFont *arg4 = 0 ;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 int val2 ;
16650 int ecode2 = 0 ;
16651 int val3 ;
16652 int ecode3 = 0 ;
16653 void *argp4 = 0 ;
16654 int res4 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 PyObject * obj2 = 0 ;
16658 PyObject * obj3 = 0 ;
16659 char * kwnames[] = {
16660 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16661 };
16662
16663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16667 }
16668 arg1 = reinterpret_cast< wxGrid * >(argp1);
16669 ecode2 = SWIG_AsVal_int(obj1, &val2);
16670 if (!SWIG_IsOK(ecode2)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16672 }
16673 arg2 = static_cast< int >(val2);
16674 ecode3 = SWIG_AsVal_int(obj2, &val3);
16675 if (!SWIG_IsOK(ecode3)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16677 }
16678 arg3 = static_cast< int >(val3);
16679 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16680 if (!SWIG_IsOK(res4)) {
16681 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16682 }
16683 if (!argp4) {
16684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16685 }
16686 arg4 = reinterpret_cast< wxFont * >(argp4);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 resultobj = SWIG_Py_Void();
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj = 0;
16702 wxGrid *arg1 = (wxGrid *) 0 ;
16703 int arg2 ;
16704 int arg3 ;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 int val2 ;
16708 int ecode2 = 0 ;
16709 int val3 ;
16710 int ecode3 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 PyObject * obj2 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16722 }
16723 arg1 = reinterpret_cast< wxGrid * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 ecode3 = SWIG_AsVal_int(obj2, &val3);
16730 if (!SWIG_IsOK(ecode3)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16732 }
16733 arg3 = static_cast< int >(val3);
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->SetDefaultCellAlignment(arg2,arg3);
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_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxGrid *arg1 = (wxGrid *) 0 ;
16750 int arg2 ;
16751 int arg3 ;
16752 int arg4 ;
16753 int arg5 ;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 int val3 ;
16759 int ecode3 = 0 ;
16760 int val4 ;
16761 int ecode4 = 0 ;
16762 int val5 ;
16763 int ecode5 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 PyObject * obj2 = 0 ;
16767 PyObject * obj3 = 0 ;
16768 PyObject * obj4 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16775 if (!SWIG_IsOK(res1)) {
16776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16777 }
16778 arg1 = reinterpret_cast< wxGrid * >(argp1);
16779 ecode2 = SWIG_AsVal_int(obj1, &val2);
16780 if (!SWIG_IsOK(ecode2)) {
16781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16782 }
16783 arg2 = static_cast< int >(val2);
16784 ecode3 = SWIG_AsVal_int(obj2, &val3);
16785 if (!SWIG_IsOK(ecode3)) {
16786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16787 }
16788 arg3 = static_cast< int >(val3);
16789 ecode4 = SWIG_AsVal_int(obj3, &val4);
16790 if (!SWIG_IsOK(ecode4)) {
16791 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16792 }
16793 arg4 = static_cast< int >(val4);
16794 ecode5 = SWIG_AsVal_int(obj4, &val5);
16795 if (!SWIG_IsOK(ecode5)) {
16796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16797 }
16798 arg5 = static_cast< int >(val5);
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 resultobj = SWIG_Py_Void();
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj = 0;
16814 wxGrid *arg1 = (wxGrid *) 0 ;
16815 bool arg2 ;
16816 void *argp1 = 0 ;
16817 int res1 = 0 ;
16818 bool val2 ;
16819 int ecode2 = 0 ;
16820 PyObject * obj0 = 0 ;
16821 PyObject * obj1 = 0 ;
16822 char * kwnames[] = {
16823 (char *) "self",(char *) "allow", NULL
16824 };
16825
16826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16828 if (!SWIG_IsOK(res1)) {
16829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16830 }
16831 arg1 = reinterpret_cast< wxGrid * >(argp1);
16832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16833 if (!SWIG_IsOK(ecode2)) {
16834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16835 }
16836 arg2 = static_cast< bool >(val2);
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 (arg1)->SetDefaultCellOverflow(arg2);
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 resultobj = SWIG_Py_Void();
16844 return resultobj;
16845 fail:
16846 return NULL;
16847 }
16848
16849
16850 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16851 PyObject *resultobj = 0;
16852 wxGrid *arg1 = (wxGrid *) 0 ;
16853 int arg2 ;
16854 int arg3 ;
16855 bool arg4 ;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 int val2 ;
16859 int ecode2 = 0 ;
16860 int val3 ;
16861 int ecode3 = 0 ;
16862 bool val4 ;
16863 int ecode4 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 PyObject * obj2 = 0 ;
16867 PyObject * obj3 = 0 ;
16868 char * kwnames[] = {
16869 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16870 };
16871
16872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16874 if (!SWIG_IsOK(res1)) {
16875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16876 }
16877 arg1 = reinterpret_cast< wxGrid * >(argp1);
16878 ecode2 = SWIG_AsVal_int(obj1, &val2);
16879 if (!SWIG_IsOK(ecode2)) {
16880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16881 }
16882 arg2 = static_cast< int >(val2);
16883 ecode3 = SWIG_AsVal_int(obj2, &val3);
16884 if (!SWIG_IsOK(ecode3)) {
16885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16886 }
16887 arg3 = static_cast< int >(val3);
16888 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16889 if (!SWIG_IsOK(ecode4)) {
16890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16891 }
16892 arg4 = static_cast< bool >(val4);
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 resultobj = SWIG_Py_Void();
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj = 0;
16908 wxGrid *arg1 = (wxGrid *) 0 ;
16909 int arg2 ;
16910 int arg3 ;
16911 int arg4 ;
16912 int arg5 ;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 int val2 ;
16916 int ecode2 = 0 ;
16917 int val3 ;
16918 int ecode3 = 0 ;
16919 int val4 ;
16920 int ecode4 = 0 ;
16921 int val5 ;
16922 int ecode5 = 0 ;
16923 PyObject * obj0 = 0 ;
16924 PyObject * obj1 = 0 ;
16925 PyObject * obj2 = 0 ;
16926 PyObject * obj3 = 0 ;
16927 PyObject * obj4 = 0 ;
16928 char * kwnames[] = {
16929 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16930 };
16931
16932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16934 if (!SWIG_IsOK(res1)) {
16935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16936 }
16937 arg1 = reinterpret_cast< wxGrid * >(argp1);
16938 ecode2 = SWIG_AsVal_int(obj1, &val2);
16939 if (!SWIG_IsOK(ecode2)) {
16940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16941 }
16942 arg2 = static_cast< int >(val2);
16943 ecode3 = SWIG_AsVal_int(obj2, &val3);
16944 if (!SWIG_IsOK(ecode3)) {
16945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16946 }
16947 arg3 = static_cast< int >(val3);
16948 ecode4 = SWIG_AsVal_int(obj3, &val4);
16949 if (!SWIG_IsOK(ecode4)) {
16950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16951 }
16952 arg4 = static_cast< int >(val4);
16953 ecode5 = SWIG_AsVal_int(obj4, &val5);
16954 if (!SWIG_IsOK(ecode5)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16956 }
16957 arg5 = static_cast< int >(val5);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_Py_Void();
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj = 0;
16973 wxGrid *arg1 = (wxGrid *) 0 ;
16974 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 void *argp2 = 0 ;
16978 int res2 = 0 ;
16979 PyObject * obj0 = 0 ;
16980 PyObject * obj1 = 0 ;
16981 char * kwnames[] = {
16982 (char *) "self",(char *) "renderer", NULL
16983 };
16984
16985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16987 if (!SWIG_IsOK(res1)) {
16988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16989 }
16990 arg1 = reinterpret_cast< wxGrid * >(argp1);
16991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16992 if (!SWIG_IsOK(res2)) {
16993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16994 }
16995 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16996 {
16997 PyThreadState* __tstate = wxPyBeginAllowThreads();
16998 (arg1)->SetDefaultRenderer(arg2);
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_Py_Void();
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxGrid *arg1 = (wxGrid *) 0 ;
17012 int arg2 ;
17013 int arg3 ;
17014 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17015 void *argp1 = 0 ;
17016 int res1 = 0 ;
17017 int val2 ;
17018 int ecode2 = 0 ;
17019 int val3 ;
17020 int ecode3 = 0 ;
17021 void *argp4 = 0 ;
17022 int res4 = 0 ;
17023 PyObject * obj0 = 0 ;
17024 PyObject * obj1 = 0 ;
17025 PyObject * obj2 = 0 ;
17026 PyObject * obj3 = 0 ;
17027 char * kwnames[] = {
17028 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17029 };
17030
17031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17033 if (!SWIG_IsOK(res1)) {
17034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17035 }
17036 arg1 = reinterpret_cast< wxGrid * >(argp1);
17037 ecode2 = SWIG_AsVal_int(obj1, &val2);
17038 if (!SWIG_IsOK(ecode2)) {
17039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17040 }
17041 arg2 = static_cast< int >(val2);
17042 ecode3 = SWIG_AsVal_int(obj2, &val3);
17043 if (!SWIG_IsOK(ecode3)) {
17044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17045 }
17046 arg3 = static_cast< int >(val3);
17047 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17048 if (!SWIG_IsOK(res4)) {
17049 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17050 }
17051 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17052 {
17053 PyThreadState* __tstate = wxPyBeginAllowThreads();
17054 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17055 wxPyEndAllowThreads(__tstate);
17056 if (PyErr_Occurred()) SWIG_fail;
17057 }
17058 resultobj = SWIG_Py_Void();
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17066 PyObject *resultobj = 0;
17067 wxGrid *arg1 = (wxGrid *) 0 ;
17068 wxGridCellRenderer *result = 0 ;
17069 void *argp1 = 0 ;
17070 int res1 = 0 ;
17071 PyObject *swig_obj[1] ;
17072
17073 if (!args) SWIG_fail;
17074 swig_obj[0] = args;
17075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17076 if (!SWIG_IsOK(res1)) {
17077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17078 }
17079 arg1 = reinterpret_cast< wxGrid * >(argp1);
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17088 }
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj = 0;
17097 wxGrid *arg1 = (wxGrid *) 0 ;
17098 int arg2 ;
17099 int arg3 ;
17100 wxGridCellRenderer *result = 0 ;
17101 void *argp1 = 0 ;
17102 int res1 = 0 ;
17103 int val2 ;
17104 int ecode2 = 0 ;
17105 int val3 ;
17106 int ecode3 = 0 ;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 PyObject * obj2 = 0 ;
17110 char * kwnames[] = {
17111 (char *) "self",(char *) "row",(char *) "col", NULL
17112 };
17113
17114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17116 if (!SWIG_IsOK(res1)) {
17117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17118 }
17119 arg1 = reinterpret_cast< wxGrid * >(argp1);
17120 ecode2 = SWIG_AsVal_int(obj1, &val2);
17121 if (!SWIG_IsOK(ecode2)) {
17122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17123 }
17124 arg2 = static_cast< int >(val2);
17125 ecode3 = SWIG_AsVal_int(obj2, &val3);
17126 if (!SWIG_IsOK(ecode3)) {
17127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17128 }
17129 arg3 = static_cast< int >(val3);
17130 {
17131 PyThreadState* __tstate = wxPyBeginAllowThreads();
17132 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17133 wxPyEndAllowThreads(__tstate);
17134 if (PyErr_Occurred()) SWIG_fail;
17135 }
17136 {
17137 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17138 }
17139 return resultobj;
17140 fail:
17141 return NULL;
17142 }
17143
17144
17145 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17146 PyObject *resultobj = 0;
17147 wxGrid *arg1 = (wxGrid *) 0 ;
17148 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17149 void *argp1 = 0 ;
17150 int res1 = 0 ;
17151 void *argp2 = 0 ;
17152 int res2 = 0 ;
17153 PyObject * obj0 = 0 ;
17154 PyObject * obj1 = 0 ;
17155 char * kwnames[] = {
17156 (char *) "self",(char *) "editor", NULL
17157 };
17158
17159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17161 if (!SWIG_IsOK(res1)) {
17162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17163 }
17164 arg1 = reinterpret_cast< wxGrid * >(argp1);
17165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17166 if (!SWIG_IsOK(res2)) {
17167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17168 }
17169 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 (arg1)->SetDefaultEditor(arg2);
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 resultobj = SWIG_Py_Void();
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj = 0;
17185 wxGrid *arg1 = (wxGrid *) 0 ;
17186 int arg2 ;
17187 int arg3 ;
17188 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17189 void *argp1 = 0 ;
17190 int res1 = 0 ;
17191 int val2 ;
17192 int ecode2 = 0 ;
17193 int val3 ;
17194 int ecode3 = 0 ;
17195 void *argp4 = 0 ;
17196 int res4 = 0 ;
17197 PyObject * obj0 = 0 ;
17198 PyObject * obj1 = 0 ;
17199 PyObject * obj2 = 0 ;
17200 PyObject * obj3 = 0 ;
17201 char * kwnames[] = {
17202 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17203 };
17204
17205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17207 if (!SWIG_IsOK(res1)) {
17208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17209 }
17210 arg1 = reinterpret_cast< wxGrid * >(argp1);
17211 ecode2 = SWIG_AsVal_int(obj1, &val2);
17212 if (!SWIG_IsOK(ecode2)) {
17213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17214 }
17215 arg2 = static_cast< int >(val2);
17216 ecode3 = SWIG_AsVal_int(obj2, &val3);
17217 if (!SWIG_IsOK(ecode3)) {
17218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17219 }
17220 arg3 = static_cast< int >(val3);
17221 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17222 if (!SWIG_IsOK(res4)) {
17223 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17224 }
17225 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 (arg1)->SetCellEditor(arg2,arg3,arg4);
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 resultobj = SWIG_Py_Void();
17233 return resultobj;
17234 fail:
17235 return NULL;
17236 }
17237
17238
17239 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *resultobj = 0;
17241 wxGrid *arg1 = (wxGrid *) 0 ;
17242 wxGridCellEditor *result = 0 ;
17243 void *argp1 = 0 ;
17244 int res1 = 0 ;
17245 PyObject *swig_obj[1] ;
17246
17247 if (!args) SWIG_fail;
17248 swig_obj[0] = args;
17249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17250 if (!SWIG_IsOK(res1)) {
17251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17252 }
17253 arg1 = reinterpret_cast< wxGrid * >(argp1);
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 {
17261 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17262 }
17263 return resultobj;
17264 fail:
17265 return NULL;
17266 }
17267
17268
17269 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17270 PyObject *resultobj = 0;
17271 wxGrid *arg1 = (wxGrid *) 0 ;
17272 int arg2 ;
17273 int arg3 ;
17274 wxGridCellEditor *result = 0 ;
17275 void *argp1 = 0 ;
17276 int res1 = 0 ;
17277 int val2 ;
17278 int ecode2 = 0 ;
17279 int val3 ;
17280 int ecode3 = 0 ;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 PyObject * obj2 = 0 ;
17284 char * kwnames[] = {
17285 (char *) "self",(char *) "row",(char *) "col", NULL
17286 };
17287
17288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17290 if (!SWIG_IsOK(res1)) {
17291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17292 }
17293 arg1 = reinterpret_cast< wxGrid * >(argp1);
17294 ecode2 = SWIG_AsVal_int(obj1, &val2);
17295 if (!SWIG_IsOK(ecode2)) {
17296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17297 }
17298 arg2 = static_cast< int >(val2);
17299 ecode3 = SWIG_AsVal_int(obj2, &val3);
17300 if (!SWIG_IsOK(ecode3)) {
17301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17302 }
17303 arg3 = static_cast< int >(val3);
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 {
17311 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17312 }
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17320 PyObject *resultobj = 0;
17321 wxGrid *arg1 = (wxGrid *) 0 ;
17322 int arg2 ;
17323 int arg3 ;
17324 wxString result;
17325 void *argp1 = 0 ;
17326 int res1 = 0 ;
17327 int val2 ;
17328 int ecode2 = 0 ;
17329 int val3 ;
17330 int ecode3 = 0 ;
17331 PyObject * obj0 = 0 ;
17332 PyObject * obj1 = 0 ;
17333 PyObject * obj2 = 0 ;
17334 char * kwnames[] = {
17335 (char *) "self",(char *) "row",(char *) "col", NULL
17336 };
17337
17338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17340 if (!SWIG_IsOK(res1)) {
17341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17342 }
17343 arg1 = reinterpret_cast< wxGrid * >(argp1);
17344 ecode2 = SWIG_AsVal_int(obj1, &val2);
17345 if (!SWIG_IsOK(ecode2)) {
17346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17347 }
17348 arg2 = static_cast< int >(val2);
17349 ecode3 = SWIG_AsVal_int(obj2, &val3);
17350 if (!SWIG_IsOK(ecode3)) {
17351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17352 }
17353 arg3 = static_cast< int >(val3);
17354 {
17355 PyThreadState* __tstate = wxPyBeginAllowThreads();
17356 result = (arg1)->GetCellValue(arg2,arg3);
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 {
17361 #if wxUSE_UNICODE
17362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17363 #else
17364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17365 #endif
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxGrid *arg1 = (wxGrid *) 0 ;
17376 int arg2 ;
17377 int arg3 ;
17378 wxString *arg4 = 0 ;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 int val2 ;
17382 int ecode2 = 0 ;
17383 int val3 ;
17384 int ecode3 = 0 ;
17385 bool temp4 = false ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 PyObject * obj2 = 0 ;
17389 PyObject * obj3 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17396 if (!SWIG_IsOK(res1)) {
17397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17398 }
17399 arg1 = reinterpret_cast< wxGrid * >(argp1);
17400 ecode2 = SWIG_AsVal_int(obj1, &val2);
17401 if (!SWIG_IsOK(ecode2)) {
17402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17403 }
17404 arg2 = static_cast< int >(val2);
17405 ecode3 = SWIG_AsVal_int(obj2, &val3);
17406 if (!SWIG_IsOK(ecode3)) {
17407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17408 }
17409 arg3 = static_cast< int >(val3);
17410 {
17411 arg4 = wxString_in_helper(obj3);
17412 if (arg4 == NULL) SWIG_fail;
17413 temp4 = true;
17414 }
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_Py_Void();
17422 {
17423 if (temp4)
17424 delete arg4;
17425 }
17426 return resultobj;
17427 fail:
17428 {
17429 if (temp4)
17430 delete arg4;
17431 }
17432 return NULL;
17433 }
17434
17435
17436 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17437 PyObject *resultobj = 0;
17438 wxGrid *arg1 = (wxGrid *) 0 ;
17439 int arg2 ;
17440 int arg3 ;
17441 bool result;
17442 void *argp1 = 0 ;
17443 int res1 = 0 ;
17444 int val2 ;
17445 int ecode2 = 0 ;
17446 int val3 ;
17447 int ecode3 = 0 ;
17448 PyObject * obj0 = 0 ;
17449 PyObject * obj1 = 0 ;
17450 PyObject * obj2 = 0 ;
17451 char * kwnames[] = {
17452 (char *) "self",(char *) "row",(char *) "col", NULL
17453 };
17454
17455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17457 if (!SWIG_IsOK(res1)) {
17458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17459 }
17460 arg1 = reinterpret_cast< wxGrid * >(argp1);
17461 ecode2 = SWIG_AsVal_int(obj1, &val2);
17462 if (!SWIG_IsOK(ecode2)) {
17463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17464 }
17465 arg2 = static_cast< int >(val2);
17466 ecode3 = SWIG_AsVal_int(obj2, &val3);
17467 if (!SWIG_IsOK(ecode3)) {
17468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17469 }
17470 arg3 = static_cast< int >(val3);
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17479 }
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17487 PyObject *resultobj = 0;
17488 wxGrid *arg1 = (wxGrid *) 0 ;
17489 int arg2 ;
17490 int arg3 ;
17491 bool arg4 = (bool) true ;
17492 void *argp1 = 0 ;
17493 int res1 = 0 ;
17494 int val2 ;
17495 int ecode2 = 0 ;
17496 int val3 ;
17497 int ecode3 = 0 ;
17498 bool val4 ;
17499 int ecode4 = 0 ;
17500 PyObject * obj0 = 0 ;
17501 PyObject * obj1 = 0 ;
17502 PyObject * obj2 = 0 ;
17503 PyObject * obj3 = 0 ;
17504 char * kwnames[] = {
17505 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17506 };
17507
17508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17510 if (!SWIG_IsOK(res1)) {
17511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17512 }
17513 arg1 = reinterpret_cast< wxGrid * >(argp1);
17514 ecode2 = SWIG_AsVal_int(obj1, &val2);
17515 if (!SWIG_IsOK(ecode2)) {
17516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17517 }
17518 arg2 = static_cast< int >(val2);
17519 ecode3 = SWIG_AsVal_int(obj2, &val3);
17520 if (!SWIG_IsOK(ecode3)) {
17521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17522 }
17523 arg3 = static_cast< int >(val3);
17524 if (obj3) {
17525 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17526 if (!SWIG_IsOK(ecode4)) {
17527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17528 }
17529 arg4 = static_cast< bool >(val4);
17530 }
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 (arg1)->SetReadOnly(arg2,arg3,arg4);
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 resultobj = SWIG_Py_Void();
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17545 PyObject *resultobj = 0;
17546 wxGrid *arg1 = (wxGrid *) 0 ;
17547 int arg2 ;
17548 bool arg3 = (bool) false ;
17549 void *argp1 = 0 ;
17550 int res1 = 0 ;
17551 int val2 ;
17552 int ecode2 = 0 ;
17553 bool val3 ;
17554 int ecode3 = 0 ;
17555 PyObject * obj0 = 0 ;
17556 PyObject * obj1 = 0 ;
17557 PyObject * obj2 = 0 ;
17558 char * kwnames[] = {
17559 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17560 };
17561
17562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17564 if (!SWIG_IsOK(res1)) {
17565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17566 }
17567 arg1 = reinterpret_cast< wxGrid * >(argp1);
17568 ecode2 = SWIG_AsVal_int(obj1, &val2);
17569 if (!SWIG_IsOK(ecode2)) {
17570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17571 }
17572 arg2 = static_cast< int >(val2);
17573 if (obj2) {
17574 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17575 if (!SWIG_IsOK(ecode3)) {
17576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17577 }
17578 arg3 = static_cast< bool >(val3);
17579 }
17580 {
17581 PyThreadState* __tstate = wxPyBeginAllowThreads();
17582 (arg1)->SelectRow(arg2,arg3);
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 resultobj = SWIG_Py_Void();
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj = 0;
17595 wxGrid *arg1 = (wxGrid *) 0 ;
17596 int arg2 ;
17597 bool arg3 = (bool) false ;
17598 void *argp1 = 0 ;
17599 int res1 = 0 ;
17600 int val2 ;
17601 int ecode2 = 0 ;
17602 bool val3 ;
17603 int ecode3 = 0 ;
17604 PyObject * obj0 = 0 ;
17605 PyObject * obj1 = 0 ;
17606 PyObject * obj2 = 0 ;
17607 char * kwnames[] = {
17608 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17609 };
17610
17611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17613 if (!SWIG_IsOK(res1)) {
17614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17615 }
17616 arg1 = reinterpret_cast< wxGrid * >(argp1);
17617 ecode2 = SWIG_AsVal_int(obj1, &val2);
17618 if (!SWIG_IsOK(ecode2)) {
17619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17620 }
17621 arg2 = static_cast< int >(val2);
17622 if (obj2) {
17623 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17624 if (!SWIG_IsOK(ecode3)) {
17625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17626 }
17627 arg3 = static_cast< bool >(val3);
17628 }
17629 {
17630 PyThreadState* __tstate = wxPyBeginAllowThreads();
17631 (arg1)->SelectCol(arg2,arg3);
17632 wxPyEndAllowThreads(__tstate);
17633 if (PyErr_Occurred()) SWIG_fail;
17634 }
17635 resultobj = SWIG_Py_Void();
17636 return resultobj;
17637 fail:
17638 return NULL;
17639 }
17640
17641
17642 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17643 PyObject *resultobj = 0;
17644 wxGrid *arg1 = (wxGrid *) 0 ;
17645 int arg2 ;
17646 int arg3 ;
17647 int arg4 ;
17648 int arg5 ;
17649 bool arg6 = (bool) false ;
17650 void *argp1 = 0 ;
17651 int res1 = 0 ;
17652 int val2 ;
17653 int ecode2 = 0 ;
17654 int val3 ;
17655 int ecode3 = 0 ;
17656 int val4 ;
17657 int ecode4 = 0 ;
17658 int val5 ;
17659 int ecode5 = 0 ;
17660 bool val6 ;
17661 int ecode6 = 0 ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 PyObject * obj2 = 0 ;
17665 PyObject * obj3 = 0 ;
17666 PyObject * obj4 = 0 ;
17667 PyObject * obj5 = 0 ;
17668 char * kwnames[] = {
17669 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17670 };
17671
17672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17674 if (!SWIG_IsOK(res1)) {
17675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17676 }
17677 arg1 = reinterpret_cast< wxGrid * >(argp1);
17678 ecode2 = SWIG_AsVal_int(obj1, &val2);
17679 if (!SWIG_IsOK(ecode2)) {
17680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17681 }
17682 arg2 = static_cast< int >(val2);
17683 ecode3 = SWIG_AsVal_int(obj2, &val3);
17684 if (!SWIG_IsOK(ecode3)) {
17685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17686 }
17687 arg3 = static_cast< int >(val3);
17688 ecode4 = SWIG_AsVal_int(obj3, &val4);
17689 if (!SWIG_IsOK(ecode4)) {
17690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17691 }
17692 arg4 = static_cast< int >(val4);
17693 ecode5 = SWIG_AsVal_int(obj4, &val5);
17694 if (!SWIG_IsOK(ecode5)) {
17695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17696 }
17697 arg5 = static_cast< int >(val5);
17698 if (obj5) {
17699 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17700 if (!SWIG_IsOK(ecode6)) {
17701 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17702 }
17703 arg6 = static_cast< bool >(val6);
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 resultobj = SWIG_Py_Void();
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 PyObject *resultobj = 0;
17720 wxGrid *arg1 = (wxGrid *) 0 ;
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_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17730 }
17731 arg1 = reinterpret_cast< wxGrid * >(argp1);
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 (arg1)->SelectAll();
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 resultobj = SWIG_Py_Void();
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17746 PyObject *resultobj = 0;
17747 wxGrid *arg1 = (wxGrid *) 0 ;
17748 bool result;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 PyObject *swig_obj[1] ;
17752
17753 if (!args) SWIG_fail;
17754 swig_obj[0] = args;
17755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17756 if (!SWIG_IsOK(res1)) {
17757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17758 }
17759 arg1 = reinterpret_cast< wxGrid * >(argp1);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (bool)(arg1)->IsSelection();
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17768 }
17769 return resultobj;
17770 fail:
17771 return NULL;
17772 }
17773
17774
17775 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17776 PyObject *resultobj = 0;
17777 wxGrid *arg1 = (wxGrid *) 0 ;
17778 void *argp1 = 0 ;
17779 int res1 = 0 ;
17780 PyObject *swig_obj[1] ;
17781
17782 if (!args) SWIG_fail;
17783 swig_obj[0] = args;
17784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17785 if (!SWIG_IsOK(res1)) {
17786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17787 }
17788 arg1 = reinterpret_cast< wxGrid * >(argp1);
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 (arg1)->ClearSelection();
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 resultobj = SWIG_Py_Void();
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj = 0;
17804 wxGrid *arg1 = (wxGrid *) 0 ;
17805 int arg2 ;
17806 int arg3 ;
17807 bool result;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 int val2 ;
17811 int ecode2 = 0 ;
17812 int val3 ;
17813 int ecode3 = 0 ;
17814 PyObject * obj0 = 0 ;
17815 PyObject * obj1 = 0 ;
17816 PyObject * obj2 = 0 ;
17817 char * kwnames[] = {
17818 (char *) "self",(char *) "row",(char *) "col", NULL
17819 };
17820
17821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17823 if (!SWIG_IsOK(res1)) {
17824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17825 }
17826 arg1 = reinterpret_cast< wxGrid * >(argp1);
17827 ecode2 = SWIG_AsVal_int(obj1, &val2);
17828 if (!SWIG_IsOK(ecode2)) {
17829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17830 }
17831 arg2 = static_cast< int >(val2);
17832 ecode3 = SWIG_AsVal_int(obj2, &val3);
17833 if (!SWIG_IsOK(ecode3)) {
17834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17835 }
17836 arg3 = static_cast< int >(val3);
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17840 wxPyEndAllowThreads(__tstate);
17841 if (PyErr_Occurred()) SWIG_fail;
17842 }
17843 {
17844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17845 }
17846 return resultobj;
17847 fail:
17848 return NULL;
17849 }
17850
17851
17852 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17853 PyObject *resultobj = 0;
17854 wxGrid *arg1 = (wxGrid *) 0 ;
17855 wxGridCellCoordsArray result;
17856 void *argp1 = 0 ;
17857 int res1 = 0 ;
17858 PyObject *swig_obj[1] ;
17859
17860 if (!args) SWIG_fail;
17861 swig_obj[0] = args;
17862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17863 if (!SWIG_IsOK(res1)) {
17864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17865 }
17866 arg1 = reinterpret_cast< wxGrid * >(argp1);
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = ((wxGrid const *)arg1)->GetSelectedCells();
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 {
17874 resultobj = wxGridCellCoordsArray_helper(result);
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxGrid *arg1 = (wxGrid *) 0 ;
17885 wxGridCellCoordsArray result;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17895 }
17896 arg1 = reinterpret_cast< wxGrid * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 {
17904 resultobj = wxGridCellCoordsArray_helper(result);
17905 }
17906 return resultobj;
17907 fail:
17908 return NULL;
17909 }
17910
17911
17912 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17913 PyObject *resultobj = 0;
17914 wxGrid *arg1 = (wxGrid *) 0 ;
17915 wxGridCellCoordsArray result;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 PyObject *swig_obj[1] ;
17919
17920 if (!args) SWIG_fail;
17921 swig_obj[0] = args;
17922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17923 if (!SWIG_IsOK(res1)) {
17924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17925 }
17926 arg1 = reinterpret_cast< wxGrid * >(argp1);
17927 {
17928 PyThreadState* __tstate = wxPyBeginAllowThreads();
17929 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17930 wxPyEndAllowThreads(__tstate);
17931 if (PyErr_Occurred()) SWIG_fail;
17932 }
17933 {
17934 resultobj = wxGridCellCoordsArray_helper(result);
17935 }
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17943 PyObject *resultobj = 0;
17944 wxGrid *arg1 = (wxGrid *) 0 ;
17945 wxArrayInt result;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 PyObject *swig_obj[1] ;
17949
17950 if (!args) SWIG_fail;
17951 swig_obj[0] = args;
17952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17953 if (!SWIG_IsOK(res1)) {
17954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17955 }
17956 arg1 = reinterpret_cast< wxGrid * >(argp1);
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 result = ((wxGrid const *)arg1)->GetSelectedRows();
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = wxArrayInt2PyList_helper(result);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 PyObject *resultobj = 0;
17974 wxGrid *arg1 = (wxGrid *) 0 ;
17975 wxArrayInt result;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 PyObject *swig_obj[1] ;
17979
17980 if (!args) SWIG_fail;
17981 swig_obj[0] = args;
17982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17983 if (!SWIG_IsOK(res1)) {
17984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17985 }
17986 arg1 = reinterpret_cast< wxGrid * >(argp1);
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 result = ((wxGrid const *)arg1)->GetSelectedCols();
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 resultobj = wxArrayInt2PyList_helper(result);
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj = 0;
18004 wxGrid *arg1 = (wxGrid *) 0 ;
18005 int arg2 ;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 int val2 ;
18009 int ecode2 = 0 ;
18010 PyObject * obj0 = 0 ;
18011 PyObject * obj1 = 0 ;
18012 char * kwnames[] = {
18013 (char *) "self",(char *) "row", NULL
18014 };
18015
18016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18018 if (!SWIG_IsOK(res1)) {
18019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18020 }
18021 arg1 = reinterpret_cast< wxGrid * >(argp1);
18022 ecode2 = SWIG_AsVal_int(obj1, &val2);
18023 if (!SWIG_IsOK(ecode2)) {
18024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18025 }
18026 arg2 = static_cast< int >(val2);
18027 {
18028 PyThreadState* __tstate = wxPyBeginAllowThreads();
18029 (arg1)->DeselectRow(arg2);
18030 wxPyEndAllowThreads(__tstate);
18031 if (PyErr_Occurred()) SWIG_fail;
18032 }
18033 resultobj = SWIG_Py_Void();
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj = 0;
18042 wxGrid *arg1 = (wxGrid *) 0 ;
18043 int arg2 ;
18044 void *argp1 = 0 ;
18045 int res1 = 0 ;
18046 int val2 ;
18047 int ecode2 = 0 ;
18048 PyObject * obj0 = 0 ;
18049 PyObject * obj1 = 0 ;
18050 char * kwnames[] = {
18051 (char *) "self",(char *) "col", NULL
18052 };
18053
18054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18056 if (!SWIG_IsOK(res1)) {
18057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18058 }
18059 arg1 = reinterpret_cast< wxGrid * >(argp1);
18060 ecode2 = SWIG_AsVal_int(obj1, &val2);
18061 if (!SWIG_IsOK(ecode2)) {
18062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18063 }
18064 arg2 = static_cast< int >(val2);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 (arg1)->DeselectCol(arg2);
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = SWIG_Py_Void();
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj = 0;
18080 wxGrid *arg1 = (wxGrid *) 0 ;
18081 int arg2 ;
18082 int arg3 ;
18083 void *argp1 = 0 ;
18084 int res1 = 0 ;
18085 int val2 ;
18086 int ecode2 = 0 ;
18087 int val3 ;
18088 int ecode3 = 0 ;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 PyObject * obj2 = 0 ;
18092 char * kwnames[] = {
18093 (char *) "self",(char *) "row",(char *) "col", NULL
18094 };
18095
18096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18100 }
18101 arg1 = reinterpret_cast< wxGrid * >(argp1);
18102 ecode2 = SWIG_AsVal_int(obj1, &val2);
18103 if (!SWIG_IsOK(ecode2)) {
18104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18105 }
18106 arg2 = static_cast< int >(val2);
18107 ecode3 = SWIG_AsVal_int(obj2, &val3);
18108 if (!SWIG_IsOK(ecode3)) {
18109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18110 }
18111 arg3 = static_cast< int >(val3);
18112 {
18113 PyThreadState* __tstate = wxPyBeginAllowThreads();
18114 (arg1)->DeselectCell(arg2,arg3);
18115 wxPyEndAllowThreads(__tstate);
18116 if (PyErr_Occurred()) SWIG_fail;
18117 }
18118 resultobj = SWIG_Py_Void();
18119 return resultobj;
18120 fail:
18121 return NULL;
18122 }
18123
18124
18125 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18126 PyObject *resultobj = 0;
18127 wxGrid *arg1 = (wxGrid *) 0 ;
18128 wxGridCellCoords *arg2 = 0 ;
18129 wxGridCellCoords *arg3 = 0 ;
18130 wxRect result;
18131 void *argp1 = 0 ;
18132 int res1 = 0 ;
18133 wxGridCellCoords temp2 ;
18134 wxGridCellCoords temp3 ;
18135 PyObject * obj0 = 0 ;
18136 PyObject * obj1 = 0 ;
18137 PyObject * obj2 = 0 ;
18138 char * kwnames[] = {
18139 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18140 };
18141
18142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18146 }
18147 arg1 = reinterpret_cast< wxGrid * >(argp1);
18148 {
18149 arg2 = &temp2;
18150 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18151 }
18152 {
18153 arg3 = &temp3;
18154 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18155 }
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *resultobj = 0;
18171 wxGrid *arg1 = (wxGrid *) 0 ;
18172 wxColour result;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 PyObject *swig_obj[1] ;
18176
18177 if (!args) SWIG_fail;
18178 swig_obj[0] = args;
18179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18180 if (!SWIG_IsOK(res1)) {
18181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18182 }
18183 arg1 = reinterpret_cast< wxGrid * >(argp1);
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *resultobj = 0;
18199 wxGrid *arg1 = (wxGrid *) 0 ;
18200 wxColour result;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 PyObject *swig_obj[1] ;
18204
18205 if (!args) SWIG_fail;
18206 swig_obj[0] = args;
18207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18210 }
18211 arg1 = reinterpret_cast< wxGrid * >(argp1);
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj = 0;
18227 wxGrid *arg1 = (wxGrid *) 0 ;
18228 wxColour *arg2 = 0 ;
18229 void *argp1 = 0 ;
18230 int res1 = 0 ;
18231 wxColour temp2 ;
18232 PyObject * obj0 = 0 ;
18233 PyObject * obj1 = 0 ;
18234 char * kwnames[] = {
18235 (char *) "self",(char *) "c", NULL
18236 };
18237
18238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18240 if (!SWIG_IsOK(res1)) {
18241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18242 }
18243 arg1 = reinterpret_cast< wxGrid * >(argp1);
18244 {
18245 arg2 = &temp2;
18246 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18247 }
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 resultobj = SWIG_Py_Void();
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj = 0;
18263 wxGrid *arg1 = (wxGrid *) 0 ;
18264 wxColour *arg2 = 0 ;
18265 void *argp1 = 0 ;
18266 int res1 = 0 ;
18267 wxColour temp2 ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char * kwnames[] = {
18271 (char *) "self",(char *) "c", NULL
18272 };
18273
18274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18278 }
18279 arg1 = reinterpret_cast< wxGrid * >(argp1);
18280 {
18281 arg2 = &temp2;
18282 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18283 }
18284 {
18285 PyThreadState* __tstate = wxPyBeginAllowThreads();
18286 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 resultobj = SWIG_Py_Void();
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj = 0;
18299 wxGrid *arg1 = (wxGrid *) 0 ;
18300 wxString *arg2 = 0 ;
18301 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18302 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18303 void *argp1 = 0 ;
18304 int res1 = 0 ;
18305 bool temp2 = false ;
18306 void *argp3 = 0 ;
18307 int res3 = 0 ;
18308 void *argp4 = 0 ;
18309 int res4 = 0 ;
18310 PyObject * obj0 = 0 ;
18311 PyObject * obj1 = 0 ;
18312 PyObject * obj2 = 0 ;
18313 PyObject * obj3 = 0 ;
18314 char * kwnames[] = {
18315 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18316 };
18317
18318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18322 }
18323 arg1 = reinterpret_cast< wxGrid * >(argp1);
18324 {
18325 arg2 = wxString_in_helper(obj1);
18326 if (arg2 == NULL) SWIG_fail;
18327 temp2 = true;
18328 }
18329 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18330 if (!SWIG_IsOK(res3)) {
18331 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18332 }
18333 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18334 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18335 if (!SWIG_IsOK(res4)) {
18336 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18337 }
18338 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18339 {
18340 PyThreadState* __tstate = wxPyBeginAllowThreads();
18341 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18342 wxPyEndAllowThreads(__tstate);
18343 if (PyErr_Occurred()) SWIG_fail;
18344 }
18345 resultobj = SWIG_Py_Void();
18346 {
18347 if (temp2)
18348 delete arg2;
18349 }
18350 return resultobj;
18351 fail:
18352 {
18353 if (temp2)
18354 delete arg2;
18355 }
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj = 0;
18362 wxGrid *arg1 = (wxGrid *) 0 ;
18363 int arg2 ;
18364 int arg3 ;
18365 wxGridCellEditor *result = 0 ;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 int val2 ;
18369 int ecode2 = 0 ;
18370 int val3 ;
18371 int ecode3 = 0 ;
18372 PyObject * obj0 = 0 ;
18373 PyObject * obj1 = 0 ;
18374 PyObject * obj2 = 0 ;
18375 char * kwnames[] = {
18376 (char *) "self",(char *) "row",(char *) "col", NULL
18377 };
18378
18379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18381 if (!SWIG_IsOK(res1)) {
18382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18383 }
18384 arg1 = reinterpret_cast< wxGrid * >(argp1);
18385 ecode2 = SWIG_AsVal_int(obj1, &val2);
18386 if (!SWIG_IsOK(ecode2)) {
18387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18388 }
18389 arg2 = static_cast< int >(val2);
18390 ecode3 = SWIG_AsVal_int(obj2, &val3);
18391 if (!SWIG_IsOK(ecode3)) {
18392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18393 }
18394 arg3 = static_cast< int >(val3);
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18398 wxPyEndAllowThreads(__tstate);
18399 if (PyErr_Occurred()) SWIG_fail;
18400 }
18401 {
18402 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18403 }
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = 0;
18412 wxGrid *arg1 = (wxGrid *) 0 ;
18413 int arg2 ;
18414 int arg3 ;
18415 wxGridCellRenderer *result = 0 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 int val2 ;
18419 int ecode2 = 0 ;
18420 int val3 ;
18421 int ecode3 = 0 ;
18422 PyObject * obj0 = 0 ;
18423 PyObject * obj1 = 0 ;
18424 PyObject * obj2 = 0 ;
18425 char * kwnames[] = {
18426 (char *) "self",(char *) "row",(char *) "col", NULL
18427 };
18428
18429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) 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_GetDefaultRendererForCell" "', 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_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18438 }
18439 arg2 = static_cast< int >(val2);
18440 ecode3 = SWIG_AsVal_int(obj2, &val3);
18441 if (!SWIG_IsOK(ecode3)) {
18442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18443 }
18444 arg3 = static_cast< int >(val3);
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18448 wxPyEndAllowThreads(__tstate);
18449 if (PyErr_Occurred()) SWIG_fail;
18450 }
18451 {
18452 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18453 }
18454 return resultobj;
18455 fail:
18456 return NULL;
18457 }
18458
18459
18460 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18461 PyObject *resultobj = 0;
18462 wxGrid *arg1 = (wxGrid *) 0 ;
18463 wxString *arg2 = 0 ;
18464 wxGridCellEditor *result = 0 ;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 bool temp2 = false ;
18468 PyObject * obj0 = 0 ;
18469 PyObject * obj1 = 0 ;
18470 char * kwnames[] = {
18471 (char *) "self",(char *) "typeName", NULL
18472 };
18473
18474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18476 if (!SWIG_IsOK(res1)) {
18477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18478 }
18479 arg1 = reinterpret_cast< wxGrid * >(argp1);
18480 {
18481 arg2 = wxString_in_helper(obj1);
18482 if (arg2 == NULL) SWIG_fail;
18483 temp2 = true;
18484 }
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18488 wxPyEndAllowThreads(__tstate);
18489 if (PyErr_Occurred()) SWIG_fail;
18490 }
18491 {
18492 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18493 }
18494 {
18495 if (temp2)
18496 delete arg2;
18497 }
18498 return resultobj;
18499 fail:
18500 {
18501 if (temp2)
18502 delete arg2;
18503 }
18504 return NULL;
18505 }
18506
18507
18508 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18509 PyObject *resultobj = 0;
18510 wxGrid *arg1 = (wxGrid *) 0 ;
18511 wxString *arg2 = 0 ;
18512 wxGridCellRenderer *result = 0 ;
18513 void *argp1 = 0 ;
18514 int res1 = 0 ;
18515 bool temp2 = false ;
18516 PyObject * obj0 = 0 ;
18517 PyObject * obj1 = 0 ;
18518 char * kwnames[] = {
18519 (char *) "self",(char *) "typeName", NULL
18520 };
18521
18522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18526 }
18527 arg1 = reinterpret_cast< wxGrid * >(argp1);
18528 {
18529 arg2 = wxString_in_helper(obj1);
18530 if (arg2 == NULL) SWIG_fail;
18531 temp2 = true;
18532 }
18533 {
18534 PyThreadState* __tstate = wxPyBeginAllowThreads();
18535 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 {
18540 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18541 }
18542 {
18543 if (temp2)
18544 delete arg2;
18545 }
18546 return resultobj;
18547 fail:
18548 {
18549 if (temp2)
18550 delete arg2;
18551 }
18552 return NULL;
18553 }
18554
18555
18556 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj = 0;
18558 wxGrid *arg1 = (wxGrid *) 0 ;
18559 int arg2 ;
18560 int arg3 ;
18561 void *argp1 = 0 ;
18562 int res1 = 0 ;
18563 int val2 ;
18564 int ecode2 = 0 ;
18565 int val3 ;
18566 int ecode3 = 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 PyObject * obj2 = 0 ;
18570 char * kwnames[] = {
18571 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18572 };
18573
18574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18576 if (!SWIG_IsOK(res1)) {
18577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18578 }
18579 arg1 = reinterpret_cast< wxGrid * >(argp1);
18580 ecode2 = SWIG_AsVal_int(obj1, &val2);
18581 if (!SWIG_IsOK(ecode2)) {
18582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18583 }
18584 arg2 = static_cast< int >(val2);
18585 ecode3 = SWIG_AsVal_int(obj2, &val3);
18586 if (!SWIG_IsOK(ecode3)) {
18587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18588 }
18589 arg3 = static_cast< int >(val3);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 (arg1)->SetMargins(arg2,arg3);
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_Py_Void();
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18604 PyObject *resultobj = 0;
18605 wxGrid *arg1 = (wxGrid *) 0 ;
18606 wxWindow *result = 0 ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 PyObject *swig_obj[1] ;
18610
18611 if (!args) SWIG_fail;
18612 swig_obj[0] = args;
18613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18614 if (!SWIG_IsOK(res1)) {
18615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18616 }
18617 arg1 = reinterpret_cast< wxGrid * >(argp1);
18618 {
18619 PyThreadState* __tstate = wxPyBeginAllowThreads();
18620 result = (wxWindow *)(arg1)->GetGridWindow();
18621 wxPyEndAllowThreads(__tstate);
18622 if (PyErr_Occurred()) SWIG_fail;
18623 }
18624 {
18625 resultobj = wxPyMake_wxObject(result, 0);
18626 }
18627 return resultobj;
18628 fail:
18629 return NULL;
18630 }
18631
18632
18633 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18634 PyObject *resultobj = 0;
18635 wxGrid *arg1 = (wxGrid *) 0 ;
18636 wxWindow *result = 0 ;
18637 void *argp1 = 0 ;
18638 int res1 = 0 ;
18639 PyObject *swig_obj[1] ;
18640
18641 if (!args) SWIG_fail;
18642 swig_obj[0] = args;
18643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18646 }
18647 arg1 = reinterpret_cast< wxGrid * >(argp1);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 {
18655 resultobj = wxPyMake_wxObject(result, 0);
18656 }
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxGrid *arg1 = (wxGrid *) 0 ;
18666 wxWindow *result = 0 ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18676 }
18677 arg1 = reinterpret_cast< wxGrid * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = wxPyMake_wxObject(result, 0);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxGrid *arg1 = (wxGrid *) 0 ;
18696 wxWindow *result = 0 ;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18706 }
18707 arg1 = reinterpret_cast< wxGrid * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 {
18715 resultobj = wxPyMake_wxObject(result, 0);
18716 }
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj = 0;
18725 wxGrid *arg1 = (wxGrid *) 0 ;
18726 int arg2 ;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 int val2 ;
18730 int ecode2 = 0 ;
18731 PyObject * obj0 = 0 ;
18732 PyObject * obj1 = 0 ;
18733 char * kwnames[] = {
18734 (char *) "self",(char *) "x", NULL
18735 };
18736
18737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18741 }
18742 arg1 = reinterpret_cast< wxGrid * >(argp1);
18743 ecode2 = SWIG_AsVal_int(obj1, &val2);
18744 if (!SWIG_IsOK(ecode2)) {
18745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18746 }
18747 arg2 = static_cast< int >(val2);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 (arg1)->SetScrollLineX(arg2);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_Py_Void();
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = 0;
18763 wxGrid *arg1 = (wxGrid *) 0 ;
18764 int arg2 ;
18765 void *argp1 = 0 ;
18766 int res1 = 0 ;
18767 int val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "y", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18779 }
18780 arg1 = reinterpret_cast< wxGrid * >(argp1);
18781 ecode2 = SWIG_AsVal_int(obj1, &val2);
18782 if (!SWIG_IsOK(ecode2)) {
18783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18784 }
18785 arg2 = static_cast< int >(val2);
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 (arg1)->SetScrollLineY(arg2);
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 resultobj = SWIG_Py_Void();
18793 return resultobj;
18794 fail:
18795 return NULL;
18796 }
18797
18798
18799 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18800 PyObject *resultobj = 0;
18801 wxGrid *arg1 = (wxGrid *) 0 ;
18802 int result;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 PyObject *swig_obj[1] ;
18806
18807 if (!args) SWIG_fail;
18808 swig_obj[0] = args;
18809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18810 if (!SWIG_IsOK(res1)) {
18811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18812 }
18813 arg1 = reinterpret_cast< wxGrid * >(argp1);
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18817 wxPyEndAllowThreads(__tstate);
18818 if (PyErr_Occurred()) SWIG_fail;
18819 }
18820 resultobj = SWIG_From_int(static_cast< int >(result));
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18828 PyObject *resultobj = 0;
18829 wxGrid *arg1 = (wxGrid *) 0 ;
18830 int result;
18831 void *argp1 = 0 ;
18832 int res1 = 0 ;
18833 PyObject *swig_obj[1] ;
18834
18835 if (!args) SWIG_fail;
18836 swig_obj[0] = args;
18837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18838 if (!SWIG_IsOK(res1)) {
18839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18840 }
18841 arg1 = reinterpret_cast< wxGrid * >(argp1);
18842 {
18843 PyThreadState* __tstate = wxPyBeginAllowThreads();
18844 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18845 wxPyEndAllowThreads(__tstate);
18846 if (PyErr_Occurred()) SWIG_fail;
18847 }
18848 resultobj = SWIG_From_int(static_cast< int >(result));
18849 return resultobj;
18850 fail:
18851 return NULL;
18852 }
18853
18854
18855 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18856 PyObject *resultobj = 0;
18857 wxGrid *arg1 = (wxGrid *) 0 ;
18858 int arg2 ;
18859 int result;
18860 void *argp1 = 0 ;
18861 int res1 = 0 ;
18862 int val2 ;
18863 int ecode2 = 0 ;
18864 PyObject * obj0 = 0 ;
18865 PyObject * obj1 = 0 ;
18866 char * kwnames[] = {
18867 (char *) "self",(char *) "x", NULL
18868 };
18869
18870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18872 if (!SWIG_IsOK(res1)) {
18873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18874 }
18875 arg1 = reinterpret_cast< wxGrid * >(argp1);
18876 ecode2 = SWIG_AsVal_int(obj1, &val2);
18877 if (!SWIG_IsOK(ecode2)) {
18878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18879 }
18880 arg2 = static_cast< int >(val2);
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 resultobj = SWIG_From_int(static_cast< int >(result));
18888 return resultobj;
18889 fail:
18890 return NULL;
18891 }
18892
18893
18894 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18895 PyObject *resultobj = 0;
18896 wxGrid *arg1 = (wxGrid *) 0 ;
18897 int arg2 ;
18898 int result;
18899 void *argp1 = 0 ;
18900 int res1 = 0 ;
18901 int val2 ;
18902 int ecode2 = 0 ;
18903 PyObject * obj0 = 0 ;
18904 PyObject * obj1 = 0 ;
18905 char * kwnames[] = {
18906 (char *) "self",(char *) "y", NULL
18907 };
18908
18909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18911 if (!SWIG_IsOK(res1)) {
18912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18913 }
18914 arg1 = reinterpret_cast< wxGrid * >(argp1);
18915 ecode2 = SWIG_AsVal_int(obj1, &val2);
18916 if (!SWIG_IsOK(ecode2)) {
18917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18918 }
18919 arg2 = static_cast< int >(val2);
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_From_int(static_cast< int >(result));
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18934 PyObject *resultobj = 0;
18935 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18936 SwigValueWrapper<wxVisualAttributes > result;
18937 int val1 ;
18938 int ecode1 = 0 ;
18939 PyObject * obj0 = 0 ;
18940 char * kwnames[] = {
18941 (char *) "variant", NULL
18942 };
18943
18944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18945 if (obj0) {
18946 ecode1 = SWIG_AsVal_int(obj0, &val1);
18947 if (!SWIG_IsOK(ecode1)) {
18948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18949 }
18950 arg1 = static_cast< wxWindowVariant >(val1);
18951 }
18952 {
18953 if (!wxPyCheckForApp()) SWIG_fail;
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = wxGrid::GetClassDefaultAttributes(arg1);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *obj;
18968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18969 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18970 return SWIG_Py_Void();
18971 }
18972
18973 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974 return SWIG_Python_InitShadowInstance(args);
18975 }
18976
18977 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj = 0;
18979 int arg1 ;
18980 wxEventType arg2 ;
18981 wxGrid *arg3 = (wxGrid *) 0 ;
18982 int arg4 = (int) -1 ;
18983 int arg5 = (int) -1 ;
18984 int arg6 = (int) -1 ;
18985 int arg7 = (int) -1 ;
18986 bool arg8 = (bool) true ;
18987 bool arg9 = (bool) false ;
18988 bool arg10 = (bool) false ;
18989 bool arg11 = (bool) false ;
18990 bool arg12 = (bool) false ;
18991 wxGridEvent *result = 0 ;
18992 int val1 ;
18993 int ecode1 = 0 ;
18994 int val2 ;
18995 int ecode2 = 0 ;
18996 void *argp3 = 0 ;
18997 int res3 = 0 ;
18998 int val4 ;
18999 int ecode4 = 0 ;
19000 int val5 ;
19001 int ecode5 = 0 ;
19002 int val6 ;
19003 int ecode6 = 0 ;
19004 int val7 ;
19005 int ecode7 = 0 ;
19006 bool val8 ;
19007 int ecode8 = 0 ;
19008 bool val9 ;
19009 int ecode9 = 0 ;
19010 bool val10 ;
19011 int ecode10 = 0 ;
19012 bool val11 ;
19013 int ecode11 = 0 ;
19014 bool val12 ;
19015 int ecode12 = 0 ;
19016 PyObject * obj0 = 0 ;
19017 PyObject * obj1 = 0 ;
19018 PyObject * obj2 = 0 ;
19019 PyObject * obj3 = 0 ;
19020 PyObject * obj4 = 0 ;
19021 PyObject * obj5 = 0 ;
19022 PyObject * obj6 = 0 ;
19023 PyObject * obj7 = 0 ;
19024 PyObject * obj8 = 0 ;
19025 PyObject * obj9 = 0 ;
19026 PyObject * obj10 = 0 ;
19027 PyObject * obj11 = 0 ;
19028 char * kwnames[] = {
19029 (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
19030 };
19031
19032 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;
19033 ecode1 = SWIG_AsVal_int(obj0, &val1);
19034 if (!SWIG_IsOK(ecode1)) {
19035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19036 }
19037 arg1 = static_cast< int >(val1);
19038 ecode2 = SWIG_AsVal_int(obj1, &val2);
19039 if (!SWIG_IsOK(ecode2)) {
19040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19041 }
19042 arg2 = static_cast< wxEventType >(val2);
19043 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19044 if (!SWIG_IsOK(res3)) {
19045 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19046 }
19047 arg3 = reinterpret_cast< wxGrid * >(argp3);
19048 if (obj3) {
19049 ecode4 = SWIG_AsVal_int(obj3, &val4);
19050 if (!SWIG_IsOK(ecode4)) {
19051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19052 }
19053 arg4 = static_cast< int >(val4);
19054 }
19055 if (obj4) {
19056 ecode5 = SWIG_AsVal_int(obj4, &val5);
19057 if (!SWIG_IsOK(ecode5)) {
19058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19059 }
19060 arg5 = static_cast< int >(val5);
19061 }
19062 if (obj5) {
19063 ecode6 = SWIG_AsVal_int(obj5, &val6);
19064 if (!SWIG_IsOK(ecode6)) {
19065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19066 }
19067 arg6 = static_cast< int >(val6);
19068 }
19069 if (obj6) {
19070 ecode7 = SWIG_AsVal_int(obj6, &val7);
19071 if (!SWIG_IsOK(ecode7)) {
19072 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19073 }
19074 arg7 = static_cast< int >(val7);
19075 }
19076 if (obj7) {
19077 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19078 if (!SWIG_IsOK(ecode8)) {
19079 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19080 }
19081 arg8 = static_cast< bool >(val8);
19082 }
19083 if (obj8) {
19084 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19085 if (!SWIG_IsOK(ecode9)) {
19086 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19087 }
19088 arg9 = static_cast< bool >(val9);
19089 }
19090 if (obj9) {
19091 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19092 if (!SWIG_IsOK(ecode10)) {
19093 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19094 }
19095 arg10 = static_cast< bool >(val10);
19096 }
19097 if (obj10) {
19098 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19099 if (!SWIG_IsOK(ecode11)) {
19100 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19101 }
19102 arg11 = static_cast< bool >(val11);
19103 }
19104 if (obj11) {
19105 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19106 if (!SWIG_IsOK(ecode12)) {
19107 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19108 }
19109 arg12 = static_cast< bool >(val12);
19110 }
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19125 PyObject *resultobj = 0;
19126 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19127 int result;
19128 void *argp1 = 0 ;
19129 int res1 = 0 ;
19130 PyObject *swig_obj[1] ;
19131
19132 if (!args) SWIG_fail;
19133 swig_obj[0] = args;
19134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19135 if (!SWIG_IsOK(res1)) {
19136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19137 }
19138 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 result = (int)(arg1)->GetRow();
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 resultobj = SWIG_From_int(static_cast< int >(result));
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19153 PyObject *resultobj = 0;
19154 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19155 int result;
19156 void *argp1 = 0 ;
19157 int res1 = 0 ;
19158 PyObject *swig_obj[1] ;
19159
19160 if (!args) SWIG_fail;
19161 swig_obj[0] = args;
19162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19163 if (!SWIG_IsOK(res1)) {
19164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19165 }
19166 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19167 {
19168 PyThreadState* __tstate = wxPyBeginAllowThreads();
19169 result = (int)(arg1)->GetCol();
19170 wxPyEndAllowThreads(__tstate);
19171 if (PyErr_Occurred()) SWIG_fail;
19172 }
19173 resultobj = SWIG_From_int(static_cast< int >(result));
19174 return resultobj;
19175 fail:
19176 return NULL;
19177 }
19178
19179
19180 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19181 PyObject *resultobj = 0;
19182 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19183 wxPoint result;
19184 void *argp1 = 0 ;
19185 int res1 = 0 ;
19186 PyObject *swig_obj[1] ;
19187
19188 if (!args) SWIG_fail;
19189 swig_obj[0] = args;
19190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19191 if (!SWIG_IsOK(res1)) {
19192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19193 }
19194 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (arg1)->GetPosition();
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19209 PyObject *resultobj = 0;
19210 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19211 bool result;
19212 void *argp1 = 0 ;
19213 int res1 = 0 ;
19214 PyObject *swig_obj[1] ;
19215
19216 if (!args) SWIG_fail;
19217 swig_obj[0] = args;
19218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19221 }
19222 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (bool)(arg1)->Selecting();
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19239 PyObject *resultobj = 0;
19240 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19241 bool result;
19242 void *argp1 = 0 ;
19243 int res1 = 0 ;
19244 PyObject *swig_obj[1] ;
19245
19246 if (!args) SWIG_fail;
19247 swig_obj[0] = args;
19248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19249 if (!SWIG_IsOK(res1)) {
19250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19251 }
19252 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 result = (bool)(arg1)->ControlDown();
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 {
19260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19261 }
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19269 PyObject *resultobj = 0;
19270 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19271 bool result;
19272 void *argp1 = 0 ;
19273 int res1 = 0 ;
19274 PyObject *swig_obj[1] ;
19275
19276 if (!args) SWIG_fail;
19277 swig_obj[0] = args;
19278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19279 if (!SWIG_IsOK(res1)) {
19280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19281 }
19282 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)(arg1)->MetaDown();
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19299 PyObject *resultobj = 0;
19300 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19301 bool result;
19302 void *argp1 = 0 ;
19303 int res1 = 0 ;
19304 PyObject *swig_obj[1] ;
19305
19306 if (!args) SWIG_fail;
19307 swig_obj[0] = args;
19308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19309 if (!SWIG_IsOK(res1)) {
19310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19311 }
19312 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (bool)(arg1)->ShiftDown();
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 {
19320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 PyObject *resultobj = 0;
19330 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19331 bool result;
19332 void *argp1 = 0 ;
19333 int res1 = 0 ;
19334 PyObject *swig_obj[1] ;
19335
19336 if (!args) SWIG_fail;
19337 swig_obj[0] = args;
19338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19339 if (!SWIG_IsOK(res1)) {
19340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19341 }
19342 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (bool)(arg1)->AltDown();
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 {
19350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19351 }
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19359 PyObject *resultobj = 0;
19360 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19361 bool result;
19362 void *argp1 = 0 ;
19363 int res1 = 0 ;
19364 PyObject *swig_obj[1] ;
19365
19366 if (!args) SWIG_fail;
19367 swig_obj[0] = args;
19368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19369 if (!SWIG_IsOK(res1)) {
19370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19371 }
19372 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (bool)(arg1)->CmdDown();
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 {
19380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19389 PyObject *obj;
19390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19391 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19392 return SWIG_Py_Void();
19393 }
19394
19395 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19396 return SWIG_Python_InitShadowInstance(args);
19397 }
19398
19399 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj = 0;
19401 int arg1 ;
19402 wxEventType arg2 ;
19403 wxGrid *arg3 = (wxGrid *) 0 ;
19404 int arg4 = (int) -1 ;
19405 int arg5 = (int) -1 ;
19406 int arg6 = (int) -1 ;
19407 bool arg7 = (bool) false ;
19408 bool arg8 = (bool) false ;
19409 bool arg9 = (bool) false ;
19410 bool arg10 = (bool) false ;
19411 wxGridSizeEvent *result = 0 ;
19412 int val1 ;
19413 int ecode1 = 0 ;
19414 int val2 ;
19415 int ecode2 = 0 ;
19416 void *argp3 = 0 ;
19417 int res3 = 0 ;
19418 int val4 ;
19419 int ecode4 = 0 ;
19420 int val5 ;
19421 int ecode5 = 0 ;
19422 int val6 ;
19423 int ecode6 = 0 ;
19424 bool val7 ;
19425 int ecode7 = 0 ;
19426 bool val8 ;
19427 int ecode8 = 0 ;
19428 bool val9 ;
19429 int ecode9 = 0 ;
19430 bool val10 ;
19431 int ecode10 = 0 ;
19432 PyObject * obj0 = 0 ;
19433 PyObject * obj1 = 0 ;
19434 PyObject * obj2 = 0 ;
19435 PyObject * obj3 = 0 ;
19436 PyObject * obj4 = 0 ;
19437 PyObject * obj5 = 0 ;
19438 PyObject * obj6 = 0 ;
19439 PyObject * obj7 = 0 ;
19440 PyObject * obj8 = 0 ;
19441 PyObject * obj9 = 0 ;
19442 char * kwnames[] = {
19443 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19444 };
19445
19446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19447 ecode1 = SWIG_AsVal_int(obj0, &val1);
19448 if (!SWIG_IsOK(ecode1)) {
19449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19450 }
19451 arg1 = static_cast< int >(val1);
19452 ecode2 = SWIG_AsVal_int(obj1, &val2);
19453 if (!SWIG_IsOK(ecode2)) {
19454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19455 }
19456 arg2 = static_cast< wxEventType >(val2);
19457 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19458 if (!SWIG_IsOK(res3)) {
19459 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19460 }
19461 arg3 = reinterpret_cast< wxGrid * >(argp3);
19462 if (obj3) {
19463 ecode4 = SWIG_AsVal_int(obj3, &val4);
19464 if (!SWIG_IsOK(ecode4)) {
19465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19466 }
19467 arg4 = static_cast< int >(val4);
19468 }
19469 if (obj4) {
19470 ecode5 = SWIG_AsVal_int(obj4, &val5);
19471 if (!SWIG_IsOK(ecode5)) {
19472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19473 }
19474 arg5 = static_cast< int >(val5);
19475 }
19476 if (obj5) {
19477 ecode6 = SWIG_AsVal_int(obj5, &val6);
19478 if (!SWIG_IsOK(ecode6)) {
19479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19480 }
19481 arg6 = static_cast< int >(val6);
19482 }
19483 if (obj6) {
19484 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19485 if (!SWIG_IsOK(ecode7)) {
19486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19487 }
19488 arg7 = static_cast< bool >(val7);
19489 }
19490 if (obj7) {
19491 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19492 if (!SWIG_IsOK(ecode8)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19494 }
19495 arg8 = static_cast< bool >(val8);
19496 }
19497 if (obj8) {
19498 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19499 if (!SWIG_IsOK(ecode9)) {
19500 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19501 }
19502 arg9 = static_cast< bool >(val9);
19503 }
19504 if (obj9) {
19505 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19506 if (!SWIG_IsOK(ecode10)) {
19507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19508 }
19509 arg10 = static_cast< bool >(val10);
19510 }
19511 {
19512 PyThreadState* __tstate = wxPyBeginAllowThreads();
19513 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19514 wxPyEndAllowThreads(__tstate);
19515 if (PyErr_Occurred()) SWIG_fail;
19516 }
19517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19525 PyObject *resultobj = 0;
19526 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19527 int result;
19528 void *argp1 = 0 ;
19529 int res1 = 0 ;
19530 PyObject *swig_obj[1] ;
19531
19532 if (!args) SWIG_fail;
19533 swig_obj[0] = args;
19534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19535 if (!SWIG_IsOK(res1)) {
19536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19537 }
19538 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 result = (int)(arg1)->GetRowOrCol();
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_From_int(static_cast< int >(result));
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19553 PyObject *resultobj = 0;
19554 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19555 wxPoint result;
19556 void *argp1 = 0 ;
19557 int res1 = 0 ;
19558 PyObject *swig_obj[1] ;
19559
19560 if (!args) SWIG_fail;
19561 swig_obj[0] = args;
19562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19563 if (!SWIG_IsOK(res1)) {
19564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19565 }
19566 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 result = (arg1)->GetPosition();
19570 wxPyEndAllowThreads(__tstate);
19571 if (PyErr_Occurred()) SWIG_fail;
19572 }
19573 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19574 return resultobj;
19575 fail:
19576 return NULL;
19577 }
19578
19579
19580 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19581 PyObject *resultobj = 0;
19582 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19583 bool result;
19584 void *argp1 = 0 ;
19585 int res1 = 0 ;
19586 PyObject *swig_obj[1] ;
19587
19588 if (!args) SWIG_fail;
19589 swig_obj[0] = args;
19590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19591 if (!SWIG_IsOK(res1)) {
19592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19593 }
19594 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (bool)(arg1)->ControlDown();
19598 wxPyEndAllowThreads(__tstate);
19599 if (PyErr_Occurred()) SWIG_fail;
19600 }
19601 {
19602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19603 }
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19611 PyObject *resultobj = 0;
19612 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19613 bool result;
19614 void *argp1 = 0 ;
19615 int res1 = 0 ;
19616 PyObject *swig_obj[1] ;
19617
19618 if (!args) SWIG_fail;
19619 swig_obj[0] = args;
19620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19621 if (!SWIG_IsOK(res1)) {
19622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19623 }
19624 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 result = (bool)(arg1)->MetaDown();
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 {
19632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19633 }
19634 return resultobj;
19635 fail:
19636 return NULL;
19637 }
19638
19639
19640 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19641 PyObject *resultobj = 0;
19642 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19643 bool result;
19644 void *argp1 = 0 ;
19645 int res1 = 0 ;
19646 PyObject *swig_obj[1] ;
19647
19648 if (!args) SWIG_fail;
19649 swig_obj[0] = args;
19650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19651 if (!SWIG_IsOK(res1)) {
19652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19653 }
19654 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19655 {
19656 PyThreadState* __tstate = wxPyBeginAllowThreads();
19657 result = (bool)(arg1)->ShiftDown();
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 {
19662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19663 }
19664 return resultobj;
19665 fail:
19666 return NULL;
19667 }
19668
19669
19670 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 PyObject *resultobj = 0;
19672 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19673 bool result;
19674 void *argp1 = 0 ;
19675 int res1 = 0 ;
19676 PyObject *swig_obj[1] ;
19677
19678 if (!args) SWIG_fail;
19679 swig_obj[0] = args;
19680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19683 }
19684 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (bool)(arg1)->AltDown();
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19693 }
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19703 bool result;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19713 }
19714 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (bool)(arg1)->CmdDown();
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19723 }
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19731 PyObject *obj;
19732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19733 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19734 return SWIG_Py_Void();
19735 }
19736
19737 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19738 return SWIG_Python_InitShadowInstance(args);
19739 }
19740
19741 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = 0;
19743 int arg1 ;
19744 wxEventType arg2 ;
19745 wxGrid *arg3 = (wxGrid *) 0 ;
19746 wxGridCellCoords *arg4 = 0 ;
19747 wxGridCellCoords *arg5 = 0 ;
19748 bool arg6 = (bool) true ;
19749 bool arg7 = (bool) false ;
19750 bool arg8 = (bool) false ;
19751 bool arg9 = (bool) false ;
19752 bool arg10 = (bool) false ;
19753 wxGridRangeSelectEvent *result = 0 ;
19754 int val1 ;
19755 int ecode1 = 0 ;
19756 int val2 ;
19757 int ecode2 = 0 ;
19758 void *argp3 = 0 ;
19759 int res3 = 0 ;
19760 wxGridCellCoords temp4 ;
19761 wxGridCellCoords temp5 ;
19762 bool val6 ;
19763 int ecode6 = 0 ;
19764 bool val7 ;
19765 int ecode7 = 0 ;
19766 bool val8 ;
19767 int ecode8 = 0 ;
19768 bool val9 ;
19769 int ecode9 = 0 ;
19770 bool val10 ;
19771 int ecode10 = 0 ;
19772 PyObject * obj0 = 0 ;
19773 PyObject * obj1 = 0 ;
19774 PyObject * obj2 = 0 ;
19775 PyObject * obj3 = 0 ;
19776 PyObject * obj4 = 0 ;
19777 PyObject * obj5 = 0 ;
19778 PyObject * obj6 = 0 ;
19779 PyObject * obj7 = 0 ;
19780 PyObject * obj8 = 0 ;
19781 PyObject * obj9 = 0 ;
19782 char * kwnames[] = {
19783 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19784 };
19785
19786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19787 ecode1 = SWIG_AsVal_int(obj0, &val1);
19788 if (!SWIG_IsOK(ecode1)) {
19789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19790 }
19791 arg1 = static_cast< int >(val1);
19792 ecode2 = SWIG_AsVal_int(obj1, &val2);
19793 if (!SWIG_IsOK(ecode2)) {
19794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19795 }
19796 arg2 = static_cast< wxEventType >(val2);
19797 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19798 if (!SWIG_IsOK(res3)) {
19799 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19800 }
19801 arg3 = reinterpret_cast< wxGrid * >(argp3);
19802 {
19803 arg4 = &temp4;
19804 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19805 }
19806 {
19807 arg5 = &temp5;
19808 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19809 }
19810 if (obj5) {
19811 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19812 if (!SWIG_IsOK(ecode6)) {
19813 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19814 }
19815 arg6 = static_cast< bool >(val6);
19816 }
19817 if (obj6) {
19818 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19819 if (!SWIG_IsOK(ecode7)) {
19820 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19821 }
19822 arg7 = static_cast< bool >(val7);
19823 }
19824 if (obj7) {
19825 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19826 if (!SWIG_IsOK(ecode8)) {
19827 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19828 }
19829 arg8 = static_cast< bool >(val8);
19830 }
19831 if (obj8) {
19832 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19833 if (!SWIG_IsOK(ecode9)) {
19834 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19835 }
19836 arg9 = static_cast< bool >(val9);
19837 }
19838 if (obj9) {
19839 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19840 if (!SWIG_IsOK(ecode10)) {
19841 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19842 }
19843 arg10 = static_cast< bool >(val10);
19844 }
19845 {
19846 PyThreadState* __tstate = wxPyBeginAllowThreads();
19847 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19848 wxPyEndAllowThreads(__tstate);
19849 if (PyErr_Occurred()) SWIG_fail;
19850 }
19851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19852 return resultobj;
19853 fail:
19854 return NULL;
19855 }
19856
19857
19858 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19859 PyObject *resultobj = 0;
19860 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19861 wxGridCellCoords result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 PyObject *swig_obj[1] ;
19865
19866 if (!args) SWIG_fail;
19867 swig_obj[0] = args;
19868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19869 if (!SWIG_IsOK(res1)) {
19870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19871 }
19872 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (arg1)->GetTopLeftCoords();
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19887 PyObject *resultobj = 0;
19888 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19889 wxGridCellCoords result;
19890 void *argp1 = 0 ;
19891 int res1 = 0 ;
19892 PyObject *swig_obj[1] ;
19893
19894 if (!args) SWIG_fail;
19895 swig_obj[0] = args;
19896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19897 if (!SWIG_IsOK(res1)) {
19898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19899 }
19900 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19901 {
19902 PyThreadState* __tstate = wxPyBeginAllowThreads();
19903 result = (arg1)->GetBottomRightCoords();
19904 wxPyEndAllowThreads(__tstate);
19905 if (PyErr_Occurred()) SWIG_fail;
19906 }
19907 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19915 PyObject *resultobj = 0;
19916 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19917 int result;
19918 void *argp1 = 0 ;
19919 int res1 = 0 ;
19920 PyObject *swig_obj[1] ;
19921
19922 if (!args) SWIG_fail;
19923 swig_obj[0] = args;
19924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19927 }
19928 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 result = (int)(arg1)->GetTopRow();
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 resultobj = SWIG_From_int(static_cast< int >(result));
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19943 PyObject *resultobj = 0;
19944 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19945 int result;
19946 void *argp1 = 0 ;
19947 int res1 = 0 ;
19948 PyObject *swig_obj[1] ;
19949
19950 if (!args) SWIG_fail;
19951 swig_obj[0] = args;
19952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19953 if (!SWIG_IsOK(res1)) {
19954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19955 }
19956 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (int)(arg1)->GetBottomRow();
19960 wxPyEndAllowThreads(__tstate);
19961 if (PyErr_Occurred()) SWIG_fail;
19962 }
19963 resultobj = SWIG_From_int(static_cast< int >(result));
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19971 PyObject *resultobj = 0;
19972 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19973 int result;
19974 void *argp1 = 0 ;
19975 int res1 = 0 ;
19976 PyObject *swig_obj[1] ;
19977
19978 if (!args) SWIG_fail;
19979 swig_obj[0] = args;
19980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19981 if (!SWIG_IsOK(res1)) {
19982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19983 }
19984 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (int)(arg1)->GetLeftCol();
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_From_int(static_cast< int >(result));
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19999 PyObject *resultobj = 0;
20000 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20001 int result;
20002 void *argp1 = 0 ;
20003 int res1 = 0 ;
20004 PyObject *swig_obj[1] ;
20005
20006 if (!args) SWIG_fail;
20007 swig_obj[0] = args;
20008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20009 if (!SWIG_IsOK(res1)) {
20010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20011 }
20012 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 result = (int)(arg1)->GetRightCol();
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 resultobj = SWIG_From_int(static_cast< int >(result));
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20027 PyObject *resultobj = 0;
20028 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20029 bool result;
20030 void *argp1 = 0 ;
20031 int res1 = 0 ;
20032 PyObject *swig_obj[1] ;
20033
20034 if (!args) SWIG_fail;
20035 swig_obj[0] = args;
20036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20039 }
20040 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 result = (bool)(arg1)->Selecting();
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20057 PyObject *resultobj = 0;
20058 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20059 bool result;
20060 void *argp1 = 0 ;
20061 int res1 = 0 ;
20062 PyObject *swig_obj[1] ;
20063
20064 if (!args) SWIG_fail;
20065 swig_obj[0] = args;
20066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20067 if (!SWIG_IsOK(res1)) {
20068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20069 }
20070 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20071 {
20072 PyThreadState* __tstate = wxPyBeginAllowThreads();
20073 result = (bool)(arg1)->ControlDown();
20074 wxPyEndAllowThreads(__tstate);
20075 if (PyErr_Occurred()) SWIG_fail;
20076 }
20077 {
20078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20079 }
20080 return resultobj;
20081 fail:
20082 return NULL;
20083 }
20084
20085
20086 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20087 PyObject *resultobj = 0;
20088 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20089 bool result;
20090 void *argp1 = 0 ;
20091 int res1 = 0 ;
20092 PyObject *swig_obj[1] ;
20093
20094 if (!args) SWIG_fail;
20095 swig_obj[0] = args;
20096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20097 if (!SWIG_IsOK(res1)) {
20098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20099 }
20100 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20101 {
20102 PyThreadState* __tstate = wxPyBeginAllowThreads();
20103 result = (bool)(arg1)->MetaDown();
20104 wxPyEndAllowThreads(__tstate);
20105 if (PyErr_Occurred()) SWIG_fail;
20106 }
20107 {
20108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20109 }
20110 return resultobj;
20111 fail:
20112 return NULL;
20113 }
20114
20115
20116 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20117 PyObject *resultobj = 0;
20118 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20119 bool result;
20120 void *argp1 = 0 ;
20121 int res1 = 0 ;
20122 PyObject *swig_obj[1] ;
20123
20124 if (!args) SWIG_fail;
20125 swig_obj[0] = args;
20126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20127 if (!SWIG_IsOK(res1)) {
20128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20129 }
20130 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (bool)(arg1)->ShiftDown();
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 {
20138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20139 }
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20149 bool result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20159 }
20160 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (bool)(arg1)->AltDown();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *resultobj = 0;
20178 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20179 bool result;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 PyObject *swig_obj[1] ;
20183
20184 if (!args) SWIG_fail;
20185 swig_obj[0] = args;
20186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20187 if (!SWIG_IsOK(res1)) {
20188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20189 }
20190 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (bool)(arg1)->CmdDown();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 {
20198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20199 }
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20207 PyObject *obj;
20208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20209 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20210 return SWIG_Py_Void();
20211 }
20212
20213 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 return SWIG_Python_InitShadowInstance(args);
20215 }
20216
20217 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj = 0;
20219 int arg1 ;
20220 wxEventType arg2 ;
20221 wxObject *arg3 = (wxObject *) 0 ;
20222 int arg4 ;
20223 int arg5 ;
20224 wxControl *arg6 = (wxControl *) 0 ;
20225 wxGridEditorCreatedEvent *result = 0 ;
20226 int val1 ;
20227 int ecode1 = 0 ;
20228 int val2 ;
20229 int ecode2 = 0 ;
20230 void *argp3 = 0 ;
20231 int res3 = 0 ;
20232 int val4 ;
20233 int ecode4 = 0 ;
20234 int val5 ;
20235 int ecode5 = 0 ;
20236 void *argp6 = 0 ;
20237 int res6 = 0 ;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 PyObject * obj2 = 0 ;
20241 PyObject * obj3 = 0 ;
20242 PyObject * obj4 = 0 ;
20243 PyObject * obj5 = 0 ;
20244 char * kwnames[] = {
20245 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20246 };
20247
20248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20249 ecode1 = SWIG_AsVal_int(obj0, &val1);
20250 if (!SWIG_IsOK(ecode1)) {
20251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20252 }
20253 arg1 = static_cast< int >(val1);
20254 ecode2 = SWIG_AsVal_int(obj1, &val2);
20255 if (!SWIG_IsOK(ecode2)) {
20256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20257 }
20258 arg2 = static_cast< wxEventType >(val2);
20259 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20260 if (!SWIG_IsOK(res3)) {
20261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20262 }
20263 arg3 = reinterpret_cast< wxObject * >(argp3);
20264 ecode4 = SWIG_AsVal_int(obj3, &val4);
20265 if (!SWIG_IsOK(ecode4)) {
20266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20267 }
20268 arg4 = static_cast< int >(val4);
20269 ecode5 = SWIG_AsVal_int(obj4, &val5);
20270 if (!SWIG_IsOK(ecode5)) {
20271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20272 }
20273 arg5 = static_cast< int >(val5);
20274 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20275 if (!SWIG_IsOK(res6)) {
20276 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20277 }
20278 arg6 = reinterpret_cast< wxControl * >(argp6);
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20293 PyObject *resultobj = 0;
20294 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20295 int result;
20296 void *argp1 = 0 ;
20297 int res1 = 0 ;
20298 PyObject *swig_obj[1] ;
20299
20300 if (!args) SWIG_fail;
20301 swig_obj[0] = args;
20302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20303 if (!SWIG_IsOK(res1)) {
20304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20305 }
20306 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = (int)(arg1)->GetRow();
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_From_int(static_cast< int >(result));
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *resultobj = 0;
20322 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20323 int result;
20324 void *argp1 = 0 ;
20325 int res1 = 0 ;
20326 PyObject *swig_obj[1] ;
20327
20328 if (!args) SWIG_fail;
20329 swig_obj[0] = args;
20330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20331 if (!SWIG_IsOK(res1)) {
20332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20333 }
20334 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (int)(arg1)->GetCol();
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 resultobj = SWIG_From_int(static_cast< int >(result));
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20349 PyObject *resultobj = 0;
20350 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20351 wxControl *result = 0 ;
20352 void *argp1 = 0 ;
20353 int res1 = 0 ;
20354 PyObject *swig_obj[1] ;
20355
20356 if (!args) SWIG_fail;
20357 swig_obj[0] = args;
20358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20359 if (!SWIG_IsOK(res1)) {
20360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20361 }
20362 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (wxControl *)(arg1)->GetControl();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 {
20370 resultobj = wxPyMake_wxObject(result, 0);
20371 }
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20379 PyObject *resultobj = 0;
20380 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20381 int arg2 ;
20382 void *argp1 = 0 ;
20383 int res1 = 0 ;
20384 int val2 ;
20385 int ecode2 = 0 ;
20386 PyObject * obj0 = 0 ;
20387 PyObject * obj1 = 0 ;
20388 char * kwnames[] = {
20389 (char *) "self",(char *) "row", NULL
20390 };
20391
20392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20394 if (!SWIG_IsOK(res1)) {
20395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20396 }
20397 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20398 ecode2 = SWIG_AsVal_int(obj1, &val2);
20399 if (!SWIG_IsOK(ecode2)) {
20400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20401 }
20402 arg2 = static_cast< int >(val2);
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 (arg1)->SetRow(arg2);
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 resultobj = SWIG_Py_Void();
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20417 PyObject *resultobj = 0;
20418 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20419 int arg2 ;
20420 void *argp1 = 0 ;
20421 int res1 = 0 ;
20422 int val2 ;
20423 int ecode2 = 0 ;
20424 PyObject * obj0 = 0 ;
20425 PyObject * obj1 = 0 ;
20426 char * kwnames[] = {
20427 (char *) "self",(char *) "col", NULL
20428 };
20429
20430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20432 if (!SWIG_IsOK(res1)) {
20433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20434 }
20435 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20436 ecode2 = SWIG_AsVal_int(obj1, &val2);
20437 if (!SWIG_IsOK(ecode2)) {
20438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20439 }
20440 arg2 = static_cast< int >(val2);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 (arg1)->SetCol(arg2);
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 resultobj = SWIG_Py_Void();
20448 return resultobj;
20449 fail:
20450 return NULL;
20451 }
20452
20453
20454 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20455 PyObject *resultobj = 0;
20456 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20457 wxControl *arg2 = (wxControl *) 0 ;
20458 void *argp1 = 0 ;
20459 int res1 = 0 ;
20460 void *argp2 = 0 ;
20461 int res2 = 0 ;
20462 PyObject * obj0 = 0 ;
20463 PyObject * obj1 = 0 ;
20464 char * kwnames[] = {
20465 (char *) "self",(char *) "ctrl", NULL
20466 };
20467
20468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20470 if (!SWIG_IsOK(res1)) {
20471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20472 }
20473 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20475 if (!SWIG_IsOK(res2)) {
20476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20477 }
20478 arg2 = reinterpret_cast< wxControl * >(argp2);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 (arg1)->SetControl(arg2);
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_Py_Void();
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *obj;
20494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20495 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20496 return SWIG_Py_Void();
20497 }
20498
20499 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20500 return SWIG_Python_InitShadowInstance(args);
20501 }
20502
20503 static PyMethodDef SwigMethods[] = {
20504 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20506 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20508 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20509 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20510 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20513 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20514 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20515 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20518 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20519 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20520 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20521 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20522 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20523 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20524 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20525 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20527 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20529 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20531 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20532 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20533 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20534 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20535 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20537 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20538 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20540 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20541 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20542 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20543 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20544 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20545 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20546 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20548 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20553 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20554 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20560 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20562 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20563 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20564 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20567 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20568 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20569 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20570 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20571 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20572 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20574 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20575 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20577 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20578 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20579 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20580 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20581 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20583 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20584 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20586 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20587 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20588 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20589 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20590 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20593 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20594 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20596 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20597 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20608 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20609 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20610 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20611 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20612 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20613 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20614 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20615 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20616 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20617 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20618 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20619 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20620 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20621 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20624 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20625 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20627 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20628 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20629 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20637 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20638 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20639 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20645 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20646 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20647 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20650 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20652 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20653 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20654 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20667 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20678 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20683 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20684 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20686 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20687 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20688 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20690 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20691 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20693 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20695 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20697 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20699 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20701 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20702 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20703 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20705 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20706 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20708 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20713 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20714 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20715 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20717 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20721 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20722 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20723 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20725 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20727 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20737 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20738 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20739 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20740 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20741 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20744 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20745 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20746 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20747 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20748 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20749 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20750 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20751 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20758 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20759 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20767 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20768 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20773 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20774 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20775 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20776 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20777 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20778 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20779 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20780 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20781 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20782 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20785 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20786 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20789 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20790 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20791 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20807 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20808 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20810 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20811 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20813 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20814 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20816 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20817 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20819 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20820 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20830 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20831 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20833 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20835 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20837 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20839 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20841 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20843 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20857 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20864 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20865 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20879 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20883 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20892 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20893 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20894 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20896 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20897 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20898 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20899 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20900 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20905 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20906 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20915 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20916 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20917 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20918 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20921 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20922 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20926 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20927 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20929 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20930 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20931 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20932 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20933 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20934 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20935 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20936 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20937 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20938 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20939 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20941 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20942 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20943 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20944 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20945 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20946 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20947 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20948 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20949 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20951 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20952 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20953 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20954 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20955 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20956 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20957 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20958 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20959 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20960 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20961 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20962 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20963 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20964 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20966 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20967 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20968 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20972 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20973 { NULL, NULL, 0, NULL }
20974 };
20975
20976
20977 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20978
20979 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20980 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20981 }
20982 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20983 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20984 }
20985 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20986 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20987 }
20988 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20989 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20990 }
20991 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20992 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20993 }
20994 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20995 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20996 }
20997 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20998 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20999 }
21000 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21001 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21002 }
21003 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21004 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21005 }
21006 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21007 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21008 }
21009 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21010 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21011 }
21012 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21013 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21014 }
21015 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21016 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21017 }
21018 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21019 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21020 }
21021 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21022 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21023 }
21024 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21025 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21026 }
21027 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21028 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21029 }
21030 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21031 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21032 }
21033 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21034 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21035 }
21036 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21037 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21038 }
21039 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21040 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21041 }
21042 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21043 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21044 }
21045 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21046 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21047 }
21048 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21049 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21050 }
21051 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21052 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21053 }
21054 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21055 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21056 }
21057 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21058 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21059 }
21060 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21061 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21062 }
21063 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21064 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21065 }
21066 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21067 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21068 }
21069 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21070 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21071 }
21072 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21073 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21074 }
21075 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21076 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21077 }
21078 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21079 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21080 }
21081 static void *_p_wxGridTo_p_wxPanel(void *x) {
21082 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21083 }
21084 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21085 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21086 }
21087 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21088 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21089 }
21090 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21091 return (void *)((wxPanel *) ((wxPyPanel *) x));
21092 }
21093 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21094 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21095 }
21096 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21097 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21098 }
21099 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21100 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21101 }
21102 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21103 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21104 }
21105 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21106 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21107 }
21108 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21109 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21110 }
21111 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21112 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21113 }
21114 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21115 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21116 }
21117 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21118 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21119 }
21120 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21121 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21122 }
21123 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21124 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21125 }
21126 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21127 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21128 }
21129 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21130 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21131 }
21132 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21133 return (void *)((wxWindow *) ((wxMenuBar *) x));
21134 }
21135 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21136 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21137 }
21138 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21139 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21140 }
21141 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21142 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21143 }
21144 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21145 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21146 }
21147 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21148 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21149 }
21150 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21151 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21152 }
21153 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21154 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21155 }
21156 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21157 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21158 }
21159 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21160 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21161 }
21162 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21163 return (void *)((wxWindow *) ((wxPanel *) x));
21164 }
21165 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21166 return (void *)((wxWindow *) ((wxStatusBar *) x));
21167 }
21168 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21169 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21170 }
21171 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21172 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21173 }
21174 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21175 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21176 }
21177 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21178 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21179 }
21180 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21181 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21182 }
21183 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21184 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21185 }
21186 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21187 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21188 }
21189 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21190 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21191 }
21192 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21193 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21194 }
21195 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21196 return (void *)((wxWindow *) ((wxSashWindow *) x));
21197 }
21198 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21199 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21200 }
21201 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21202 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21203 }
21204 static void *_p_wxControlTo_p_wxWindow(void *x) {
21205 return (void *)((wxWindow *) ((wxControl *) x));
21206 }
21207 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21208 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21209 }
21210 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21211 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21212 }
21213 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21214 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21215 }
21216 static void *_p_wxGridTo_p_wxWindow(void *x) {
21217 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21218 }
21219 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21220 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21221 }
21222 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21223 return (void *)((wxWindow *) ((wxPyWindow *) x));
21224 }
21225 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21226 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21227 }
21228 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21229 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21230 }
21231 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21232 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21233 }
21234 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21235 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21236 }
21237 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21238 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21239 }
21240 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21241 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21242 }
21243 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21244 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21245 }
21246 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21247 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21248 }
21249 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21250 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21251 }
21252 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21253 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21254 }
21255 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21256 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21257 }
21258 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21259 return (void *)((wxControl *) ((wxControlWithItems *) x));
21260 }
21261 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21263 }
21264 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21265 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21266 }
21267 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21268 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21269 }
21270 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21271 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21272 }
21273 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21274 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21275 }
21276 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21277 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21278 }
21279 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21280 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21281 }
21282 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21283 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21284 }
21285 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21286 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21287 }
21288 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21289 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21290 }
21291 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21292 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21293 }
21294 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21295 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21296 }
21297 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21298 return (void *)((wxEvent *) ((wxPyEvent *) x));
21299 }
21300 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21301 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21302 }
21303 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21304 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21305 }
21306 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21307 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21308 }
21309 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21310 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21311 }
21312 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21313 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21314 }
21315 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21316 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21317 }
21318 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21319 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21320 }
21321 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21322 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21323 }
21324 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21325 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21326 }
21327 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21328 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21329 }
21330 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21331 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21332 }
21333 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21334 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21335 }
21336 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21337 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21338 }
21339 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21340 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21341 }
21342 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21343 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21344 }
21345 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21346 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21347 }
21348 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21349 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21350 }
21351 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21352 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21353 }
21354 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21355 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21356 }
21357 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21358 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21359 }
21360 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21361 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21362 }
21363 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21364 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21365 }
21366 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21367 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21368 }
21369 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21370 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21371 }
21372 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21373 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21374 }
21375 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21376 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21377 }
21378 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21379 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21380 }
21381 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21382 return (void *)((wxEvent *) ((wxShowEvent *) x));
21383 }
21384 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21385 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21386 }
21387 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21388 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21389 }
21390 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21391 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21392 }
21393 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21394 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21395 }
21396 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21397 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21398 }
21399 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21400 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21401 }
21402 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21403 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21404 }
21405 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21406 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21407 }
21408 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21409 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21410 }
21411 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21412 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21413 }
21414 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21415 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21416 }
21417 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21418 return (void *)((wxObject *) ((wxSizerItem *) x));
21419 }
21420 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21421 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21422 }
21423 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21425 }
21426 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21427 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21428 }
21429 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21430 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21431 }
21432 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21433 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21434 }
21435 static void *_p_wxSizerTo_p_wxObject(void *x) {
21436 return (void *)((wxObject *) ((wxSizer *) x));
21437 }
21438 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21439 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21440 }
21441 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21442 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21443 }
21444 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21445 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21446 }
21447 static void *_p_wxEventTo_p_wxObject(void *x) {
21448 return (void *)((wxObject *) ((wxEvent *) x));
21449 }
21450 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21451 return (void *)((wxObject *) ((wxFontData *) x));
21452 }
21453 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21454 return (void *)((wxObject *) ((wxPrintData *) x));
21455 }
21456 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21457 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21458 }
21459 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21460 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21461 }
21462 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21463 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21464 }
21465 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21466 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21467 }
21468 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21469 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21470 }
21471 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21472 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21473 }
21474 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21475 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21476 }
21477 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21479 }
21480 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21481 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21482 }
21483 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21484 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21485 }
21486 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21487 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21488 }
21489 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21490 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21491 }
21492 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21493 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21494 }
21495 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21496 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21497 }
21498 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21499 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21500 }
21501 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21503 }
21504 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21505 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21506 }
21507 static void *_p_wxControlTo_p_wxObject(void *x) {
21508 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21509 }
21510 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21511 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21512 }
21513 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21514 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21515 }
21516 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21517 return (void *)((wxObject *) ((wxFSFile *) x));
21518 }
21519 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21520 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21521 }
21522 static void *_p_wxGridTo_p_wxObject(void *x) {
21523 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21524 }
21525 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21527 }
21528 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21530 }
21531 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) ((wxColourData *) x));
21533 }
21534 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21536 }
21537 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21539 }
21540 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21542 }
21543 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21545 }
21546 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21548 }
21549 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21551 }
21552 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21554 }
21555 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21557 }
21558 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21560 }
21561 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21563 }
21564 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21566 }
21567 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21569 }
21570 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21572 }
21573 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21575 }
21576 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) ((wxPrinter *) x));
21578 }
21579 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) ((wxMenuItem *) x));
21581 }
21582 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21584 }
21585 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21587 }
21588 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21590 }
21591 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21593 }
21594 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21596 }
21597 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21599 }
21600 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21602 }
21603 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21605 }
21606 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21608 }
21609 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21611 }
21612 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21614 }
21615 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21617 }
21618 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21620 }
21621 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21623 }
21624 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21626 }
21627 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21629 }
21630 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21632 }
21633 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21635 }
21636 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21638 }
21639 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21641 }
21642 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) ((wxImageHandler *) x));
21644 }
21645 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21647 }
21648 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21650 }
21651 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) ((wxEvtHandler *) x));
21653 }
21654 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21656 }
21657 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21659 }
21660 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21661 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21662 }
21663 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21664 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21665 }
21666 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21667 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21668 }
21669 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21670 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21671 }
21672 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21673 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21674 }
21675 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21677 }
21678 static void *_p_wxImageTo_p_wxObject(void *x) {
21679 return (void *)((wxObject *) ((wxImage *) x));
21680 }
21681 static void *_p_wxFrameTo_p_wxObject(void *x) {
21682 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21683 }
21684 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21685 return (void *)((wxObject *) ((wxPyPrintout *) x));
21686 }
21687 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21688 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21689 }
21690 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21691 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21692 }
21693 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21694 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21695 }
21696 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21697 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21698 }
21699 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21701 }
21702 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21703 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21704 }
21705 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21706 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21707 }
21708 static void *_p_wxWindowTo_p_wxObject(void *x) {
21709 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21710 }
21711 static void *_p_wxMenuTo_p_wxObject(void *x) {
21712 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21713 }
21714 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21715 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21716 }
21717 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21718 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21719 }
21720 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21721 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21722 }
21723 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21724 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21725 }
21726 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21727 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21728 }
21729 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21730 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21731 }
21732 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21733 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21734 }
21735 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21736 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21737 }
21738 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21739 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21740 }
21741 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21742 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21743 }
21744 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21745 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21746 }
21747 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21748 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21749 }
21750 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21751 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21752 }
21753 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21754 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21755 }
21756 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21757 return (void *)((wxObject *) ((wxPrintPreview *) x));
21758 }
21759 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21760 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21761 }
21762 static void *_p_wxPanelTo_p_wxObject(void *x) {
21763 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21764 }
21765 static void *_p_wxDialogTo_p_wxObject(void *x) {
21766 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21767 }
21768 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21769 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21770 }
21771 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21772 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21773 }
21774 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21775 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21776 }
21777 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21778 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21779 }
21780 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21781 return (void *)((wxObject *) ((wxPrintDialog *) x));
21782 }
21783 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21784 return (void *)((wxObject *) ((wxFileSystem *) x));
21785 }
21786 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21787 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21788 }
21789 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21790 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21791 }
21792 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21793 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21794 }
21795 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21796 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21797 }
21798 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21799 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21800 }
21801 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21802 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21803 }
21804 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21805 return (void *)((wxObject *) ((wxGridTableBase *) x));
21806 }
21807 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21808 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21809 }
21810 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21811 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21812 }
21813 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21814 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21815 }
21816 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21817 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21818 }
21819 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21820 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21821 }
21822 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21823 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21824 }
21825 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21826 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21827 }
21828 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21830 }
21831 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21832 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21833 }
21834 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21835 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21836 }
21837 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21838 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21839 }
21840 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21841 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21842 }
21843 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21844 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21845 }
21846 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21847 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21848 }
21849 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21850 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21851 }
21852 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21853 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21854 }
21855 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21856 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21857 }
21858 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21859 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21860 }
21861 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21862 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21863 }
21864 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21865 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21866 }
21867 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21868 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21869 }
21870 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21871 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21872 }
21873 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21874 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21875 }
21876 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21877 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21878 }
21879 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21880 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21881 }
21882 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
21883 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21884 }
21885 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21886 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21887 }
21888 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21889 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21890 }
21891 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21892 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21893 }
21894 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21895 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21896 }
21897 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21898 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21899 }
21900 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21901 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21902 }
21903 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21904 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21905 }
21906 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21907 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21908 }
21909 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21910 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21911 }
21912 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21913 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21914 }
21915 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21916 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21917 }
21918 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21919 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21920 }
21921 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21922 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21923 }
21924 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21925 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21926 }
21927 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21928 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21929 }
21930 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21931 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21932 }
21933 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21934 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21935 }
21936 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21937 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21938 }
21939 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21940 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21941 }
21942 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21943 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21944 }
21945 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21946 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21947 }
21948 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21949 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21950 }
21951 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21952 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21953 }
21954 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21955 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21956 }
21957 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21958 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21959 }
21960 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21961 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21962 }
21963 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21964 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21965 }
21966 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21967 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21968 }
21969 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21970 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21971 }
21972 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21973 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21974 }
21975 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21976 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21977 }
21978 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21979 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21980 }
21981 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21982 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21983 }
21984 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21985 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21986 }
21987 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21988 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21989 }
21990 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21991 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21992 }
21993 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21994 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21995 }
21996 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21997 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21998 }
21999 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22000 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22001 }
22002 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22003 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22004 }
22005 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22006 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22007 }
22008 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22009 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22010 }
22011 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22012 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22013 }
22014 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22015 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22016 }
22017 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22018 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22019 }
22020 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22021 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22022 }
22023 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22024 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22025 }
22026 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22027 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22028 }
22029 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22030 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22031 }
22032 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22033 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22034 }
22035 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22036 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22037 }
22038 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22039 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22040 }
22041 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22042 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22043 }
22044 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22045 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22046 }
22047 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22048 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22049 }
22050 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22051 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22052 }
22053 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22054 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22055 }
22056 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22057 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22058 }
22059 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22060 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22061 }
22062 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22063 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22064 }
22065 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22066 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22067 }
22068 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22069 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22070 }
22071 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22072 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22073 }
22074 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22075 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22076 }
22077 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22078 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22079 }
22080 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22081 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22082 }
22083 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22084 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22085 }
22086 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22087 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22088 }
22089 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22090 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22091 }
22092 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22093 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22094 }
22095 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22096 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};
22097 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22098 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22099 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22100 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22101 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22102 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22103 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22104 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22105 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22106 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22107 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22108 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22109 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22110 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22111 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22112 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22113 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22114 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22115 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22116 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22117 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22118 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22119 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22120 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22121 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22122 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22123 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22124 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22125 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22126 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22127 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22128 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22129 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22130 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22131 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22132 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22133 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22134 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22135 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22136 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22137 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22138 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22139 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22140 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22141 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22142 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22143 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22144 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22145 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22146 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22147 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22148 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22149 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22150 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22151 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22152 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22153 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22154 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22155 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22156 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22157 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22158 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22159 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22160 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22161 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22162 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22163 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22164 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22165 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22166 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22167 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22168 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22169 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22170 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22171 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22172 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22173 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22174 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22175 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22176 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22177 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22178 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22179 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22180 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22181 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22182 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22183 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22184 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22185 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22186 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22187 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22188 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22189 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22190 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22191 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22192 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22193 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22194 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22195 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22196 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22197 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22198 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22199 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22200 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22201 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22202 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22203 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22204 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22205 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22206 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22207 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22208 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22209 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22210 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22211 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22212 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22213 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22214 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22215 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22216 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22217 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22218 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22219 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22220 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22221 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22222 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22223 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22224 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22225 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22226 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22227 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22228 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22229 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22230 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22231 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22232 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22233 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22234 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22235 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22236 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22237 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22238 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22239 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22240 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22241 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22242 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22243 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22244 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22245 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22246 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22247 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22248 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22249 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22250 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22255 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22256 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22257 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22258 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22259 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22260 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22263 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22265 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22266 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22267 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22272 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22273 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22274 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22275 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22276 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22277 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22278 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22279 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22280 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22281 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22282 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22283 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22284 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22285 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22286
22287 static swig_type_info *swig_type_initial[] = {
22288 &_swigt__p_char,
22289 &_swigt__p_form_ops_t,
22290 &_swigt__p_int,
22291 &_swigt__p_long,
22292 &_swigt__p_unsigned_char,
22293 &_swigt__p_unsigned_int,
22294 &_swigt__p_unsigned_long,
22295 &_swigt__p_wxANIHandler,
22296 &_swigt__p_wxAcceleratorTable,
22297 &_swigt__p_wxActivateEvent,
22298 &_swigt__p_wxArrayString,
22299 &_swigt__p_wxBMPHandler,
22300 &_swigt__p_wxBoxSizer,
22301 &_swigt__p_wxCURHandler,
22302 &_swigt__p_wxCalculateLayoutEvent,
22303 &_swigt__p_wxChildFocusEvent,
22304 &_swigt__p_wxClipboardTextEvent,
22305 &_swigt__p_wxCloseEvent,
22306 &_swigt__p_wxColour,
22307 &_swigt__p_wxColourData,
22308 &_swigt__p_wxColourDialog,
22309 &_swigt__p_wxCommandEvent,
22310 &_swigt__p_wxContextMenuEvent,
22311 &_swigt__p_wxControl,
22312 &_swigt__p_wxControlWithItems,
22313 &_swigt__p_wxDC,
22314 &_swigt__p_wxDateEvent,
22315 &_swigt__p_wxDialog,
22316 &_swigt__p_wxDirDialog,
22317 &_swigt__p_wxDisplayChangedEvent,
22318 &_swigt__p_wxDropFilesEvent,
22319 &_swigt__p_wxDuplexMode,
22320 &_swigt__p_wxEraseEvent,
22321 &_swigt__p_wxEvent,
22322 &_swigt__p_wxEvtHandler,
22323 &_swigt__p_wxFSFile,
22324 &_swigt__p_wxFileDialog,
22325 &_swigt__p_wxFileSystem,
22326 &_swigt__p_wxFindDialogEvent,
22327 &_swigt__p_wxFindReplaceData,
22328 &_swigt__p_wxFindReplaceDialog,
22329 &_swigt__p_wxFlexGridSizer,
22330 &_swigt__p_wxFocusEvent,
22331 &_swigt__p_wxFont,
22332 &_swigt__p_wxFontData,
22333 &_swigt__p_wxFontDialog,
22334 &_swigt__p_wxFrame,
22335 &_swigt__p_wxGBSizerItem,
22336 &_swigt__p_wxGIFHandler,
22337 &_swigt__p_wxGrid,
22338 &_swigt__p_wxGridBagSizer,
22339 &_swigt__p_wxGridCellAttr,
22340 &_swigt__p_wxGridCellAttrProvider,
22341 &_swigt__p_wxGridCellAutoWrapStringEditor,
22342 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22343 &_swigt__p_wxGridCellBoolEditor,
22344 &_swigt__p_wxGridCellBoolRenderer,
22345 &_swigt__p_wxGridCellChoiceEditor,
22346 &_swigt__p_wxGridCellCoords,
22347 &_swigt__p_wxGridCellDateTimeRenderer,
22348 &_swigt__p_wxGridCellEditor,
22349 &_swigt__p_wxGridCellEnumEditor,
22350 &_swigt__p_wxGridCellEnumRenderer,
22351 &_swigt__p_wxGridCellFloatEditor,
22352 &_swigt__p_wxGridCellFloatRenderer,
22353 &_swigt__p_wxGridCellNumberEditor,
22354 &_swigt__p_wxGridCellNumberRenderer,
22355 &_swigt__p_wxGridCellRenderer,
22356 &_swigt__p_wxGridCellStringRenderer,
22357 &_swigt__p_wxGridCellTextEditor,
22358 &_swigt__p_wxGridCellWorker,
22359 &_swigt__p_wxGridEditorCreatedEvent,
22360 &_swigt__p_wxGridEvent,
22361 &_swigt__p_wxGridRangeSelectEvent,
22362 &_swigt__p_wxGridSizeEvent,
22363 &_swigt__p_wxGridSizer,
22364 &_swigt__p_wxGridStringTable,
22365 &_swigt__p_wxGridTableBase,
22366 &_swigt__p_wxGridTableMessage,
22367 &_swigt__p_wxICOHandler,
22368 &_swigt__p_wxIconizeEvent,
22369 &_swigt__p_wxIdleEvent,
22370 &_swigt__p_wxImage,
22371 &_swigt__p_wxImageHandler,
22372 &_swigt__p_wxIndividualLayoutConstraint,
22373 &_swigt__p_wxInitDialogEvent,
22374 &_swigt__p_wxJPEGHandler,
22375 &_swigt__p_wxKeyEvent,
22376 &_swigt__p_wxLayoutAlgorithm,
22377 &_swigt__p_wxLayoutConstraints,
22378 &_swigt__p_wxMDIChildFrame,
22379 &_swigt__p_wxMDIClientWindow,
22380 &_swigt__p_wxMDIParentFrame,
22381 &_swigt__p_wxMaximizeEvent,
22382 &_swigt__p_wxMenu,
22383 &_swigt__p_wxMenuBar,
22384 &_swigt__p_wxMenuEvent,
22385 &_swigt__p_wxMenuItem,
22386 &_swigt__p_wxMessageDialog,
22387 &_swigt__p_wxMiniFrame,
22388 &_swigt__p_wxMouseCaptureChangedEvent,
22389 &_swigt__p_wxMouseCaptureLostEvent,
22390 &_swigt__p_wxMouseEvent,
22391 &_swigt__p_wxMoveEvent,
22392 &_swigt__p_wxMultiChoiceDialog,
22393 &_swigt__p_wxNavigationKeyEvent,
22394 &_swigt__p_wxNcPaintEvent,
22395 &_swigt__p_wxNotifyEvent,
22396 &_swigt__p_wxNumberEntryDialog,
22397 &_swigt__p_wxObject,
22398 &_swigt__p_wxPCXHandler,
22399 &_swigt__p_wxPNGHandler,
22400 &_swigt__p_wxPNMHandler,
22401 &_swigt__p_wxPageSetupDialog,
22402 &_swigt__p_wxPageSetupDialogData,
22403 &_swigt__p_wxPaintEvent,
22404 &_swigt__p_wxPaletteChangedEvent,
22405 &_swigt__p_wxPanel,
22406 &_swigt__p_wxPaperSize,
22407 &_swigt__p_wxPasswordEntryDialog,
22408 &_swigt__p_wxPen,
22409 &_swigt__p_wxPoint,
22410 &_swigt__p_wxPopupWindow,
22411 &_swigt__p_wxPreviewCanvas,
22412 &_swigt__p_wxPreviewControlBar,
22413 &_swigt__p_wxPreviewFrame,
22414 &_swigt__p_wxPrintData,
22415 &_swigt__p_wxPrintDialog,
22416 &_swigt__p_wxPrintDialogData,
22417 &_swigt__p_wxPrintPreview,
22418 &_swigt__p_wxPrinter,
22419 &_swigt__p_wxProgressDialog,
22420 &_swigt__p_wxPyApp,
22421 &_swigt__p_wxPyCommandEvent,
22422 &_swigt__p_wxPyEvent,
22423 &_swigt__p_wxPyGridCellAttrProvider,
22424 &_swigt__p_wxPyGridCellEditor,
22425 &_swigt__p_wxPyGridCellRenderer,
22426 &_swigt__p_wxPyGridTableBase,
22427 &_swigt__p_wxPyHtmlListBox,
22428 &_swigt__p_wxPyImageHandler,
22429 &_swigt__p_wxPyPanel,
22430 &_swigt__p_wxPyPopupTransientWindow,
22431 &_swigt__p_wxPyPreviewControlBar,
22432 &_swigt__p_wxPyPreviewFrame,
22433 &_swigt__p_wxPyPrintPreview,
22434 &_swigt__p_wxPyPrintout,
22435 &_swigt__p_wxPyScrolledWindow,
22436 &_swigt__p_wxPySizer,
22437 &_swigt__p_wxPyTaskBarIcon,
22438 &_swigt__p_wxPyVListBox,
22439 &_swigt__p_wxPyVScrolledWindow,
22440 &_swigt__p_wxPyValidator,
22441 &_swigt__p_wxPyWindow,
22442 &_swigt__p_wxQueryLayoutInfoEvent,
22443 &_swigt__p_wxQueryNewPaletteEvent,
22444 &_swigt__p_wxRect,
22445 &_swigt__p_wxSashEvent,
22446 &_swigt__p_wxSashLayoutWindow,
22447 &_swigt__p_wxSashWindow,
22448 &_swigt__p_wxScrollEvent,
22449 &_swigt__p_wxScrollWinEvent,
22450 &_swigt__p_wxScrolledWindow,
22451 &_swigt__p_wxSetCursorEvent,
22452 &_swigt__p_wxShowEvent,
22453 &_swigt__p_wxSingleChoiceDialog,
22454 &_swigt__p_wxSize,
22455 &_swigt__p_wxSizeEvent,
22456 &_swigt__p_wxSizer,
22457 &_swigt__p_wxSizerItem,
22458 &_swigt__p_wxSplashScreen,
22459 &_swigt__p_wxSplashScreenWindow,
22460 &_swigt__p_wxSplitterEvent,
22461 &_swigt__p_wxSplitterWindow,
22462 &_swigt__p_wxStaticBoxSizer,
22463 &_swigt__p_wxStatusBar,
22464 &_swigt__p_wxStdDialogButtonSizer,
22465 &_swigt__p_wxString,
22466 &_swigt__p_wxSysColourChangedEvent,
22467 &_swigt__p_wxTIFFHandler,
22468 &_swigt__p_wxTaskBarIconEvent,
22469 &_swigt__p_wxTextEntryDialog,
22470 &_swigt__p_wxTipWindow,
22471 &_swigt__p_wxTopLevelWindow,
22472 &_swigt__p_wxUpdateUIEvent,
22473 &_swigt__p_wxValidator,
22474 &_swigt__p_wxVisualAttributes,
22475 &_swigt__p_wxWindow,
22476 &_swigt__p_wxWindowCreateEvent,
22477 &_swigt__p_wxWindowDestroyEvent,
22478 &_swigt__p_wxXPMHandler,
22479 };
22480
22481 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22482 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22483 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22484 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22485 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22486 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22487 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22488 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22489 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22490 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22491 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22492 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22493 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22494 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22495 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22496 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22497 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22498 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22499 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22500 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22501 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22502 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}};
22503 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22504 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}};
22505 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22506 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22507 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22508 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22509 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22510 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22511 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22512 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22513 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22514 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22515 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22516 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22517 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22518 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22519 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22520 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22521 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22522 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22523 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22524 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22525 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22526 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22527 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22528 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22529 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22530 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22531 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22532 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22533 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22534 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22535 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22536 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
22537 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22538 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22539 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22540 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22541 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22542 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22543 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22544 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22545 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22546 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22547 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22548 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22549 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22550 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22551 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22552 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22553 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22554 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22555 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22556 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22557 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22558 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22559 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22560 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22561 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22562 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22563 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22564 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22565 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22566 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22567 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22568 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22569 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22570 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22571 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22572 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22573 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22574 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22575 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22576 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22577 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22578 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22579 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22580 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22581 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22582 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22583 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22584 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22585 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22586 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}};
22587 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22588 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22589 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22590 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22591 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}};
22592 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22593 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22594 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}};
22595 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22596 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22597 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22598 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22599 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22600 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22601 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}};
22602 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}};
22603 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}};
22604 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}};
22605 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22606 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22607 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22608 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22609 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22610 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}};
22611 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22612 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22613 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}};
22614 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22615 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22616 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22617 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22618 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22619 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22620 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22621 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22622 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22623 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22624 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22625 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22626 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22627 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22628 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22629 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22630 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22631 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22632 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22643 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22644 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22645 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22646 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22647 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22653 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22654 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22655 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22656 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
22658 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}};
22659 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22662 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22663 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22667 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}};
22668 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22672
22673 static swig_cast_info *swig_cast_initial[] = {
22674 _swigc__p_char,
22675 _swigc__p_form_ops_t,
22676 _swigc__p_int,
22677 _swigc__p_long,
22678 _swigc__p_unsigned_char,
22679 _swigc__p_unsigned_int,
22680 _swigc__p_unsigned_long,
22681 _swigc__p_wxANIHandler,
22682 _swigc__p_wxAcceleratorTable,
22683 _swigc__p_wxActivateEvent,
22684 _swigc__p_wxArrayString,
22685 _swigc__p_wxBMPHandler,
22686 _swigc__p_wxBoxSizer,
22687 _swigc__p_wxCURHandler,
22688 _swigc__p_wxCalculateLayoutEvent,
22689 _swigc__p_wxChildFocusEvent,
22690 _swigc__p_wxClipboardTextEvent,
22691 _swigc__p_wxCloseEvent,
22692 _swigc__p_wxColour,
22693 _swigc__p_wxColourData,
22694 _swigc__p_wxColourDialog,
22695 _swigc__p_wxCommandEvent,
22696 _swigc__p_wxContextMenuEvent,
22697 _swigc__p_wxControl,
22698 _swigc__p_wxControlWithItems,
22699 _swigc__p_wxDC,
22700 _swigc__p_wxDateEvent,
22701 _swigc__p_wxDialog,
22702 _swigc__p_wxDirDialog,
22703 _swigc__p_wxDisplayChangedEvent,
22704 _swigc__p_wxDropFilesEvent,
22705 _swigc__p_wxDuplexMode,
22706 _swigc__p_wxEraseEvent,
22707 _swigc__p_wxEvent,
22708 _swigc__p_wxEvtHandler,
22709 _swigc__p_wxFSFile,
22710 _swigc__p_wxFileDialog,
22711 _swigc__p_wxFileSystem,
22712 _swigc__p_wxFindDialogEvent,
22713 _swigc__p_wxFindReplaceData,
22714 _swigc__p_wxFindReplaceDialog,
22715 _swigc__p_wxFlexGridSizer,
22716 _swigc__p_wxFocusEvent,
22717 _swigc__p_wxFont,
22718 _swigc__p_wxFontData,
22719 _swigc__p_wxFontDialog,
22720 _swigc__p_wxFrame,
22721 _swigc__p_wxGBSizerItem,
22722 _swigc__p_wxGIFHandler,
22723 _swigc__p_wxGrid,
22724 _swigc__p_wxGridBagSizer,
22725 _swigc__p_wxGridCellAttr,
22726 _swigc__p_wxGridCellAttrProvider,
22727 _swigc__p_wxGridCellAutoWrapStringEditor,
22728 _swigc__p_wxGridCellAutoWrapStringRenderer,
22729 _swigc__p_wxGridCellBoolEditor,
22730 _swigc__p_wxGridCellBoolRenderer,
22731 _swigc__p_wxGridCellChoiceEditor,
22732 _swigc__p_wxGridCellCoords,
22733 _swigc__p_wxGridCellDateTimeRenderer,
22734 _swigc__p_wxGridCellEditor,
22735 _swigc__p_wxGridCellEnumEditor,
22736 _swigc__p_wxGridCellEnumRenderer,
22737 _swigc__p_wxGridCellFloatEditor,
22738 _swigc__p_wxGridCellFloatRenderer,
22739 _swigc__p_wxGridCellNumberEditor,
22740 _swigc__p_wxGridCellNumberRenderer,
22741 _swigc__p_wxGridCellRenderer,
22742 _swigc__p_wxGridCellStringRenderer,
22743 _swigc__p_wxGridCellTextEditor,
22744 _swigc__p_wxGridCellWorker,
22745 _swigc__p_wxGridEditorCreatedEvent,
22746 _swigc__p_wxGridEvent,
22747 _swigc__p_wxGridRangeSelectEvent,
22748 _swigc__p_wxGridSizeEvent,
22749 _swigc__p_wxGridSizer,
22750 _swigc__p_wxGridStringTable,
22751 _swigc__p_wxGridTableBase,
22752 _swigc__p_wxGridTableMessage,
22753 _swigc__p_wxICOHandler,
22754 _swigc__p_wxIconizeEvent,
22755 _swigc__p_wxIdleEvent,
22756 _swigc__p_wxImage,
22757 _swigc__p_wxImageHandler,
22758 _swigc__p_wxIndividualLayoutConstraint,
22759 _swigc__p_wxInitDialogEvent,
22760 _swigc__p_wxJPEGHandler,
22761 _swigc__p_wxKeyEvent,
22762 _swigc__p_wxLayoutAlgorithm,
22763 _swigc__p_wxLayoutConstraints,
22764 _swigc__p_wxMDIChildFrame,
22765 _swigc__p_wxMDIClientWindow,
22766 _swigc__p_wxMDIParentFrame,
22767 _swigc__p_wxMaximizeEvent,
22768 _swigc__p_wxMenu,
22769 _swigc__p_wxMenuBar,
22770 _swigc__p_wxMenuEvent,
22771 _swigc__p_wxMenuItem,
22772 _swigc__p_wxMessageDialog,
22773 _swigc__p_wxMiniFrame,
22774 _swigc__p_wxMouseCaptureChangedEvent,
22775 _swigc__p_wxMouseCaptureLostEvent,
22776 _swigc__p_wxMouseEvent,
22777 _swigc__p_wxMoveEvent,
22778 _swigc__p_wxMultiChoiceDialog,
22779 _swigc__p_wxNavigationKeyEvent,
22780 _swigc__p_wxNcPaintEvent,
22781 _swigc__p_wxNotifyEvent,
22782 _swigc__p_wxNumberEntryDialog,
22783 _swigc__p_wxObject,
22784 _swigc__p_wxPCXHandler,
22785 _swigc__p_wxPNGHandler,
22786 _swigc__p_wxPNMHandler,
22787 _swigc__p_wxPageSetupDialog,
22788 _swigc__p_wxPageSetupDialogData,
22789 _swigc__p_wxPaintEvent,
22790 _swigc__p_wxPaletteChangedEvent,
22791 _swigc__p_wxPanel,
22792 _swigc__p_wxPaperSize,
22793 _swigc__p_wxPasswordEntryDialog,
22794 _swigc__p_wxPen,
22795 _swigc__p_wxPoint,
22796 _swigc__p_wxPopupWindow,
22797 _swigc__p_wxPreviewCanvas,
22798 _swigc__p_wxPreviewControlBar,
22799 _swigc__p_wxPreviewFrame,
22800 _swigc__p_wxPrintData,
22801 _swigc__p_wxPrintDialog,
22802 _swigc__p_wxPrintDialogData,
22803 _swigc__p_wxPrintPreview,
22804 _swigc__p_wxPrinter,
22805 _swigc__p_wxProgressDialog,
22806 _swigc__p_wxPyApp,
22807 _swigc__p_wxPyCommandEvent,
22808 _swigc__p_wxPyEvent,
22809 _swigc__p_wxPyGridCellAttrProvider,
22810 _swigc__p_wxPyGridCellEditor,
22811 _swigc__p_wxPyGridCellRenderer,
22812 _swigc__p_wxPyGridTableBase,
22813 _swigc__p_wxPyHtmlListBox,
22814 _swigc__p_wxPyImageHandler,
22815 _swigc__p_wxPyPanel,
22816 _swigc__p_wxPyPopupTransientWindow,
22817 _swigc__p_wxPyPreviewControlBar,
22818 _swigc__p_wxPyPreviewFrame,
22819 _swigc__p_wxPyPrintPreview,
22820 _swigc__p_wxPyPrintout,
22821 _swigc__p_wxPyScrolledWindow,
22822 _swigc__p_wxPySizer,
22823 _swigc__p_wxPyTaskBarIcon,
22824 _swigc__p_wxPyVListBox,
22825 _swigc__p_wxPyVScrolledWindow,
22826 _swigc__p_wxPyValidator,
22827 _swigc__p_wxPyWindow,
22828 _swigc__p_wxQueryLayoutInfoEvent,
22829 _swigc__p_wxQueryNewPaletteEvent,
22830 _swigc__p_wxRect,
22831 _swigc__p_wxSashEvent,
22832 _swigc__p_wxSashLayoutWindow,
22833 _swigc__p_wxSashWindow,
22834 _swigc__p_wxScrollEvent,
22835 _swigc__p_wxScrollWinEvent,
22836 _swigc__p_wxScrolledWindow,
22837 _swigc__p_wxSetCursorEvent,
22838 _swigc__p_wxShowEvent,
22839 _swigc__p_wxSingleChoiceDialog,
22840 _swigc__p_wxSize,
22841 _swigc__p_wxSizeEvent,
22842 _swigc__p_wxSizer,
22843 _swigc__p_wxSizerItem,
22844 _swigc__p_wxSplashScreen,
22845 _swigc__p_wxSplashScreenWindow,
22846 _swigc__p_wxSplitterEvent,
22847 _swigc__p_wxSplitterWindow,
22848 _swigc__p_wxStaticBoxSizer,
22849 _swigc__p_wxStatusBar,
22850 _swigc__p_wxStdDialogButtonSizer,
22851 _swigc__p_wxString,
22852 _swigc__p_wxSysColourChangedEvent,
22853 _swigc__p_wxTIFFHandler,
22854 _swigc__p_wxTaskBarIconEvent,
22855 _swigc__p_wxTextEntryDialog,
22856 _swigc__p_wxTipWindow,
22857 _swigc__p_wxTopLevelWindow,
22858 _swigc__p_wxUpdateUIEvent,
22859 _swigc__p_wxValidator,
22860 _swigc__p_wxVisualAttributes,
22861 _swigc__p_wxWindow,
22862 _swigc__p_wxWindowCreateEvent,
22863 _swigc__p_wxWindowDestroyEvent,
22864 _swigc__p_wxXPMHandler,
22865 };
22866
22867
22868 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22869
22870 static swig_const_info swig_const_table[] = {
22871 {0, 0, 0, 0.0, 0, 0}};
22872
22873 #ifdef __cplusplus
22874 }
22875 #endif
22876 /* -----------------------------------------------------------------------------
22877 * Type initialization:
22878 * This problem is tough by the requirement that no dynamic
22879 * memory is used. Also, since swig_type_info structures store pointers to
22880 * swig_cast_info structures and swig_cast_info structures store pointers back
22881 * to swig_type_info structures, we need some lookup code at initialization.
22882 * The idea is that swig generates all the structures that are needed.
22883 * The runtime then collects these partially filled structures.
22884 * The SWIG_InitializeModule function takes these initial arrays out of
22885 * swig_module, and does all the lookup, filling in the swig_module.types
22886 * array with the correct data and linking the correct swig_cast_info
22887 * structures together.
22888 *
22889 * The generated swig_type_info structures are assigned staticly to an initial
22890 * array. We just loop though that array, and handle each type individually.
22891 * First we lookup if this type has been already loaded, and if so, use the
22892 * loaded structure instead of the generated one. Then we have to fill in the
22893 * cast linked list. The cast data is initially stored in something like a
22894 * two-dimensional array. Each row corresponds to a type (there are the same
22895 * number of rows as there are in the swig_type_initial array). Each entry in
22896 * a column is one of the swig_cast_info structures for that type.
22897 * The cast_initial array is actually an array of arrays, because each row has
22898 * a variable number of columns. So to actually build the cast linked list,
22899 * we find the array of casts associated with the type, and loop through it
22900 * adding the casts to the list. The one last trick we need to do is making
22901 * sure the type pointer in the swig_cast_info struct is correct.
22902 *
22903 * First off, we lookup the cast->type name to see if it is already loaded.
22904 * There are three cases to handle:
22905 * 1) If the cast->type has already been loaded AND the type we are adding
22906 * casting info to has not been loaded (it is in this module), THEN we
22907 * replace the cast->type pointer with the type pointer that has already
22908 * been loaded.
22909 * 2) If BOTH types (the one we are adding casting info to, and the
22910 * cast->type) are loaded, THEN the cast info has already been loaded by
22911 * the previous module so we just ignore it.
22912 * 3) Finally, if cast->type has not already been loaded, then we add that
22913 * swig_cast_info to the linked list (because the cast->type) pointer will
22914 * be correct.
22915 * ----------------------------------------------------------------------------- */
22916
22917 #ifdef __cplusplus
22918 extern "C" {
22919 #if 0
22920 } /* c-mode */
22921 #endif
22922 #endif
22923
22924 #if 0
22925 #define SWIGRUNTIME_DEBUG
22926 #endif
22927
22928 SWIGRUNTIME void
22929 SWIG_InitializeModule(void *clientdata) {
22930 size_t i;
22931 swig_module_info *module_head;
22932 static int init_run = 0;
22933
22934 clientdata = clientdata;
22935
22936 if (init_run) return;
22937 init_run = 1;
22938
22939 /* Initialize the swig_module */
22940 swig_module.type_initial = swig_type_initial;
22941 swig_module.cast_initial = swig_cast_initial;
22942
22943 /* Try and load any already created modules */
22944 module_head = SWIG_GetModule(clientdata);
22945 if (module_head) {
22946 swig_module.next = module_head->next;
22947 module_head->next = &swig_module;
22948 } else {
22949 /* This is the first module loaded */
22950 swig_module.next = &swig_module;
22951 SWIG_SetModule(clientdata, &swig_module);
22952 }
22953
22954 /* Now work on filling in swig_module.types */
22955 #ifdef SWIGRUNTIME_DEBUG
22956 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22957 #endif
22958 for (i = 0; i < swig_module.size; ++i) {
22959 swig_type_info *type = 0;
22960 swig_type_info *ret;
22961 swig_cast_info *cast;
22962
22963 #ifdef SWIGRUNTIME_DEBUG
22964 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22965 #endif
22966
22967 /* if there is another module already loaded */
22968 if (swig_module.next != &swig_module) {
22969 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22970 }
22971 if (type) {
22972 /* Overwrite clientdata field */
22973 #ifdef SWIGRUNTIME_DEBUG
22974 printf("SWIG_InitializeModule: found type %s\n", type->name);
22975 #endif
22976 if (swig_module.type_initial[i]->clientdata) {
22977 type->clientdata = swig_module.type_initial[i]->clientdata;
22978 #ifdef SWIGRUNTIME_DEBUG
22979 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22980 #endif
22981 }
22982 } else {
22983 type = swig_module.type_initial[i];
22984 }
22985
22986 /* Insert casting types */
22987 cast = swig_module.cast_initial[i];
22988 while (cast->type) {
22989 /* Don't need to add information already in the list */
22990 ret = 0;
22991 #ifdef SWIGRUNTIME_DEBUG
22992 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22993 #endif
22994 if (swig_module.next != &swig_module) {
22995 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22996 #ifdef SWIGRUNTIME_DEBUG
22997 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22998 #endif
22999 }
23000 if (ret) {
23001 if (type == swig_module.type_initial[i]) {
23002 #ifdef SWIGRUNTIME_DEBUG
23003 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23004 #endif
23005 cast->type = ret;
23006 ret = 0;
23007 } else {
23008 /* Check for casting already in the list */
23009 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23010 #ifdef SWIGRUNTIME_DEBUG
23011 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23012 #endif
23013 if (!ocast) ret = 0;
23014 }
23015 }
23016
23017 if (!ret) {
23018 #ifdef SWIGRUNTIME_DEBUG
23019 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23020 #endif
23021 if (type->cast) {
23022 type->cast->prev = cast;
23023 cast->next = type->cast;
23024 }
23025 type->cast = cast;
23026 }
23027 cast++;
23028 }
23029 /* Set entry in modules->types array equal to the type */
23030 swig_module.types[i] = type;
23031 }
23032 swig_module.types[i] = 0;
23033
23034 #ifdef SWIGRUNTIME_DEBUG
23035 printf("**** SWIG_InitializeModule: Cast List ******\n");
23036 for (i = 0; i < swig_module.size; ++i) {
23037 int j = 0;
23038 swig_cast_info *cast = swig_module.cast_initial[i];
23039 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23040 while (cast->type) {
23041 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23042 cast++;
23043 ++j;
23044 }
23045 printf("---- Total casts: %d\n",j);
23046 }
23047 printf("**** SWIG_InitializeModule: Cast List ******\n");
23048 #endif
23049 }
23050
23051 /* This function will propagate the clientdata field of type to
23052 * any new swig_type_info structures that have been added into the list
23053 * of equivalent types. It is like calling
23054 * SWIG_TypeClientData(type, clientdata) a second time.
23055 */
23056 SWIGRUNTIME void
23057 SWIG_PropagateClientData(void) {
23058 size_t i;
23059 swig_cast_info *equiv;
23060 static int init_run = 0;
23061
23062 if (init_run) return;
23063 init_run = 1;
23064
23065 for (i = 0; i < swig_module.size; i++) {
23066 if (swig_module.types[i]->clientdata) {
23067 equiv = swig_module.types[i]->cast;
23068 while (equiv) {
23069 if (!equiv->converter) {
23070 if (equiv->type && !equiv->type->clientdata)
23071 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23072 }
23073 equiv = equiv->next;
23074 }
23075 }
23076 }
23077 }
23078
23079 #ifdef __cplusplus
23080 #if 0
23081 {
23082 /* c-mode */
23083 #endif
23084 }
23085 #endif
23086
23087
23088
23089 #ifdef __cplusplus
23090 extern "C" {
23091 #endif
23092
23093 /* Python-specific SWIG API */
23094 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23095 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23096 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23097
23098 /* -----------------------------------------------------------------------------
23099 * global variable support code.
23100 * ----------------------------------------------------------------------------- */
23101
23102 typedef struct swig_globalvar {
23103 char *name; /* Name of global variable */
23104 PyObject *(*get_attr)(void); /* Return the current value */
23105 int (*set_attr)(PyObject *); /* Set the value */
23106 struct swig_globalvar *next;
23107 } swig_globalvar;
23108
23109 typedef struct swig_varlinkobject {
23110 PyObject_HEAD
23111 swig_globalvar *vars;
23112 } swig_varlinkobject;
23113
23114 SWIGINTERN PyObject *
23115 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23116 return PyString_FromString("<Swig global variables>");
23117 }
23118
23119 SWIGINTERN PyObject *
23120 swig_varlink_str(swig_varlinkobject *v) {
23121 PyObject *str = PyString_FromString("(");
23122 swig_globalvar *var;
23123 for (var = v->vars; var; var=var->next) {
23124 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23125 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23126 }
23127 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23128 return str;
23129 }
23130
23131 SWIGINTERN int
23132 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23133 PyObject *str = swig_varlink_str(v);
23134 fprintf(fp,"Swig global variables ");
23135 fprintf(fp,"%s\n", PyString_AsString(str));
23136 Py_DECREF(str);
23137 return 0;
23138 }
23139
23140 SWIGINTERN void
23141 swig_varlink_dealloc(swig_varlinkobject *v) {
23142 swig_globalvar *var = v->vars;
23143 while (var) {
23144 swig_globalvar *n = var->next;
23145 free(var->name);
23146 free(var);
23147 var = n;
23148 }
23149 }
23150
23151 SWIGINTERN PyObject *
23152 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23153 PyObject *res = NULL;
23154 swig_globalvar *var = v->vars;
23155 while (var) {
23156 if (strcmp(var->name,n) == 0) {
23157 res = (*var->get_attr)();
23158 break;
23159 }
23160 var = var->next;
23161 }
23162 if (res == NULL && !PyErr_Occurred()) {
23163 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23164 }
23165 return res;
23166 }
23167
23168 SWIGINTERN int
23169 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23170 int res = 1;
23171 swig_globalvar *var = v->vars;
23172 while (var) {
23173 if (strcmp(var->name,n) == 0) {
23174 res = (*var->set_attr)(p);
23175 break;
23176 }
23177 var = var->next;
23178 }
23179 if (res == 1 && !PyErr_Occurred()) {
23180 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23181 }
23182 return res;
23183 }
23184
23185 SWIGINTERN PyTypeObject*
23186 swig_varlink_type(void) {
23187 static char varlink__doc__[] = "Swig var link object";
23188 static PyTypeObject varlink_type;
23189 static int type_init = 0;
23190 if (!type_init) {
23191 const PyTypeObject tmp
23192 = {
23193 PyObject_HEAD_INIT(NULL)
23194 0, /* Number of items in variable part (ob_size) */
23195 (char *)"swigvarlink", /* Type name (tp_name) */
23196 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23197 0, /* Itemsize (tp_itemsize) */
23198 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23199 (printfunc) swig_varlink_print, /* Print (tp_print) */
23200 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23201 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23202 0, /* tp_compare */
23203 (reprfunc) swig_varlink_repr, /* tp_repr */
23204 0, /* tp_as_number */
23205 0, /* tp_as_sequence */
23206 0, /* tp_as_mapping */
23207 0, /* tp_hash */
23208 0, /* tp_call */
23209 (reprfunc)swig_varlink_str, /* tp_str */
23210 0, /* tp_getattro */
23211 0, /* tp_setattro */
23212 0, /* tp_as_buffer */
23213 0, /* tp_flags */
23214 varlink__doc__, /* tp_doc */
23215 0, /* tp_traverse */
23216 0, /* tp_clear */
23217 0, /* tp_richcompare */
23218 0, /* tp_weaklistoffset */
23219 #if PY_VERSION_HEX >= 0x02020000
23220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23221 #endif
23222 #if PY_VERSION_HEX >= 0x02030000
23223 0, /* tp_del */
23224 #endif
23225 #ifdef COUNT_ALLOCS
23226 0,0,0,0 /* tp_alloc -> tp_next */
23227 #endif
23228 };
23229 varlink_type = tmp;
23230 varlink_type.ob_type = &PyType_Type;
23231 type_init = 1;
23232 }
23233 return &varlink_type;
23234 }
23235
23236 /* Create a variable linking object for use later */
23237 SWIGINTERN PyObject *
23238 SWIG_Python_newvarlink(void) {
23239 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23240 if (result) {
23241 result->vars = 0;
23242 }
23243 return ((PyObject*) result);
23244 }
23245
23246 SWIGINTERN void
23247 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23248 swig_varlinkobject *v = (swig_varlinkobject *) p;
23249 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23250 if (gv) {
23251 size_t size = strlen(name)+1;
23252 gv->name = (char *)malloc(size);
23253 if (gv->name) {
23254 strncpy(gv->name,name,size);
23255 gv->get_attr = get_attr;
23256 gv->set_attr = set_attr;
23257 gv->next = v->vars;
23258 }
23259 }
23260 v->vars = gv;
23261 }
23262
23263 SWIGINTERN PyObject *
23264 SWIG_globals() {
23265 static PyObject *_SWIG_globals = 0;
23266 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23267 return _SWIG_globals;
23268 }
23269
23270 /* -----------------------------------------------------------------------------
23271 * constants/methods manipulation
23272 * ----------------------------------------------------------------------------- */
23273
23274 /* Install Constants */
23275 SWIGINTERN void
23276 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23277 PyObject *obj = 0;
23278 size_t i;
23279 for (i = 0; constants[i].type; ++i) {
23280 switch(constants[i].type) {
23281 case SWIG_PY_POINTER:
23282 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23283 break;
23284 case SWIG_PY_BINARY:
23285 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23286 break;
23287 default:
23288 obj = 0;
23289 break;
23290 }
23291 if (obj) {
23292 PyDict_SetItemString(d, constants[i].name, obj);
23293 Py_DECREF(obj);
23294 }
23295 }
23296 }
23297
23298 /* -----------------------------------------------------------------------------*/
23299 /* Fix SwigMethods to carry the callback ptrs when needed */
23300 /* -----------------------------------------------------------------------------*/
23301
23302 SWIGINTERN void
23303 SWIG_Python_FixMethods(PyMethodDef *methods,
23304 swig_const_info *const_table,
23305 swig_type_info **types,
23306 swig_type_info **types_initial) {
23307 size_t i;
23308 for (i = 0; methods[i].ml_name; ++i) {
23309 const char *c = methods[i].ml_doc;
23310 if (c && (c = strstr(c, "swig_ptr: "))) {
23311 int j;
23312 swig_const_info *ci = 0;
23313 const char *name = c + 10;
23314 for (j = 0; const_table[j].type; ++j) {
23315 if (strncmp(const_table[j].name, name,
23316 strlen(const_table[j].name)) == 0) {
23317 ci = &(const_table[j]);
23318 break;
23319 }
23320 }
23321 if (ci) {
23322 size_t shift = (ci->ptype) - types;
23323 swig_type_info *ty = types_initial[shift];
23324 size_t ldoc = (c - methods[i].ml_doc);
23325 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23326 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23327 if (ndoc) {
23328 char *buff = ndoc;
23329 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23330 if (ptr) {
23331 strncpy(buff, methods[i].ml_doc, ldoc);
23332 buff += ldoc;
23333 strncpy(buff, "swig_ptr: ", 10);
23334 buff += 10;
23335 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23336 methods[i].ml_doc = ndoc;
23337 }
23338 }
23339 }
23340 }
23341 }
23342 }
23343
23344 #ifdef __cplusplus
23345 }
23346 #endif
23347
23348 /* -----------------------------------------------------------------------------*
23349 * Partial Init method
23350 * -----------------------------------------------------------------------------*/
23351
23352 #ifdef __cplusplus
23353 extern "C"
23354 #endif
23355 SWIGEXPORT void SWIG_init(void) {
23356 PyObject *m, *d;
23357
23358 /* Fix SwigMethods to carry the callback ptrs when needed */
23359 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23360
23361 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23362 d = PyModule_GetDict(m);
23363
23364 SWIG_InitializeModule(0);
23365 SWIG_InstallConstants(d,swig_const_table);
23366
23367
23368 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23369 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23370 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23371 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23372 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23373 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23374 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23375 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23376 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23377 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23378 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23379 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23380 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23381 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23382 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23383 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23384 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23385 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23386 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23387 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23388 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23389 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23390 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23391 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23392 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23393 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23394 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23395 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23396 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23397 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23398 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23399 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23400 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23401 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23402 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23403 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23404 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23405 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23406 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23407 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23408 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23409 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23410 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23411 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23412 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23413 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23414 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23415 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23416 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23417 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23418 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23419 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23420 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23421 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23422 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23423 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23424
23425
23426 }
23427
wxWidgets (Impactor)