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


762876462b89254d2c065613f196750f42ce2abd
[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_wxTGAHandler swig_types[179]
2646 #define SWIGTYPE_p_wxTIFFHandler swig_types[180]
2647 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[181]
2648 #define SWIGTYPE_p_wxTextEntryDialog swig_types[182]
2649 #define SWIGTYPE_p_wxTipWindow swig_types[183]
2650 #define SWIGTYPE_p_wxTopLevelWindow swig_types[184]
2651 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[185]
2652 #define SWIGTYPE_p_wxValidator swig_types[186]
2653 #define SWIGTYPE_p_wxVisualAttributes swig_types[187]
2654 #define SWIGTYPE_p_wxWindow swig_types[188]
2655 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[189]
2656 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[190]
2657 #define SWIGTYPE_p_wxXPMHandler swig_types[191]
2658 static swig_type_info *swig_types[193];
2659 static swig_module_info swig_module = {swig_types, 192, 0, 0, 0, 0};
2660 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2661 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2662
2663 /* -------- TYPES TABLE (END) -------- */
2664
2665 #if (PY_VERSION_HEX <= 0x02000000)
2666 # if !defined(SWIG_PYTHON_CLASSIC)
2667 # error "This python version requires to use swig with the '-classic' option"
2668 # endif
2669 #endif
2670 #if (PY_VERSION_HEX <= 0x02020000)
2671 # error "This python version requires to use swig with the '-nomodern' option"
2672 #endif
2673 #if (PY_VERSION_HEX <= 0x02020000)
2674 # error "This python version requires to use swig with the '-nomodernargs' option"
2675 #endif
2676 #ifndef METH_O
2677 # error "This python version requires to use swig with the '-nofastunpack' option"
2678 #endif
2679
2680 /*-----------------------------------------------
2681 @(target):= _grid.so
2682 ------------------------------------------------*/
2683 #define SWIG_init init_grid
2684
2685 #define SWIG_name "_grid"
2686
2687 #define SWIGVERSION 0x010329
2688
2689
2690 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2691 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2692
2693
2694 #include <stdexcept>
2695
2696
2697 namespace swig {
2698 class PyObject_ptr {
2699 protected:
2700 PyObject *_obj;
2701
2702 public:
2703 PyObject_ptr() :_obj(0)
2704 {
2705 }
2706
2707 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2708 {
2709 Py_XINCREF(_obj);
2710 }
2711
2712 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2713 {
2714 if (initial_ref) Py_XINCREF(_obj);
2715 }
2716
2717 PyObject_ptr & operator=(const PyObject_ptr& item)
2718 {
2719 Py_XINCREF(item._obj);
2720 Py_XDECREF(_obj);
2721 _obj = item._obj;
2722 return *this;
2723 }
2724
2725 ~PyObject_ptr()
2726 {
2727 Py_XDECREF(_obj);
2728 }
2729
2730 operator PyObject *() const
2731 {
2732 return _obj;
2733 }
2734
2735 PyObject *operator->() const
2736 {
2737 return _obj;
2738 }
2739 };
2740 }
2741
2742
2743 namespace swig {
2744 struct PyObject_var : PyObject_ptr {
2745 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2746
2747 PyObject_var & operator = (PyObject* obj)
2748 {
2749 Py_XDECREF(_obj);
2750 _obj = obj;
2751 return *this;
2752 }
2753 };
2754 }
2755
2756
2757 #include "wx/wxPython/wxPython.h"
2758 #include "wx/wxPython/pyclasses.h"
2759 #include "wx/wxPython/printfw.h"
2760
2761 #include <wx/grid.h>
2762 #include <wx/generic/gridctrl.h>
2763
2764
2765 static const wxString wxPyEmptyString(wxEmptyString);
2766 static const wxString wxPyGridNameStr(wxGridNameStr);
2767 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2768
2769
2770 #define wxPyMake_TEMPLATE(TYPE) \
2771 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2772 PyObject* target = NULL; \
2773 if (source) { \
2774 /* Check if there is already a pointer to a Python object in the \
2775 OOR data that we can use. */ \
2776 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2777 if (data) { \
2778 target = data->m_obj; \
2779 if (target) \
2780 Py_INCREF(target); \
2781 } \
2782 /* Otherwise make a new wrapper for it the old fashioned way and \
2783 give it the OOR treatment */ \
2784 if (! target) { \
2785 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2786 if (target) \
2787 source->SetClientObject(new wxPyOORClientData(target)); \
2788 } \
2789 } else { /* source was NULL so return None. */ \
2790 Py_INCREF(Py_None); target = Py_None; \
2791 } \
2792 return target; \
2793 } \
2794
2795
2796 wxPyMake_TEMPLATE(wxGridCellRenderer)
2797 wxPyMake_TEMPLATE(wxGridCellEditor)
2798 wxPyMake_TEMPLATE(wxGridCellAttr)
2799 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2800 wxPyMake_TEMPLATE(wxGridTableBase)
2801
2802
2803
2804 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2805 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2806 wxGridCellAttr* rval = NULL; \
2807 bool found; \
2808 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2809 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2810 PyObject* ro; \
2811 wxGridCellAttr* ptr; \
2812 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2813 if (ro) { \
2814 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2815 rval = ptr; \
2816 Py_DECREF(ro); \
2817 } \
2818 } \
2819 wxPyEndBlockThreads(blocked); \
2820 if (! found) \
2821 rval = PCLASS::CBNAME(a, b, c); \
2822 return rval; \
2823 }
2824
2825
2826 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2827 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2828 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2829 bool found; \
2830 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2831 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2832 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2833 Py_DECREF(obj); \
2834 } \
2835 wxPyEndBlockThreads(blocked); \
2836 if (! found) \
2837 PCLASS::CBNAME(attr, a, b); \
2838 }
2839
2840
2841
2842 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2843 void CBNAME(wxGridCellAttr *attr, int val) { \
2844 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2845 bool found; \
2846 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2847 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2848 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2849 Py_DECREF(obj); \
2850 } \
2851 wxPyEndBlockThreads(blocked); \
2852 if (! found) \
2853 PCLASS::CBNAME(attr, val); \
2854 }
2855
2856
2857
2858 #define PYCALLBACK_INT__pure(CBNAME) \
2859 int CBNAME() { \
2860 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2861 int rval = 0; \
2862 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2863 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2864 wxPyEndBlockThreads(blocked); \
2865 return rval; \
2866 }
2867
2868
2869
2870 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2871 bool CBNAME(int a, int b) { \
2872 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2873 bool rval = 0; \
2874 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2875 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2876 wxPyEndBlockThreads(blocked); \
2877 return rval; \
2878 }
2879
2880
2881 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2882 wxString CBNAME(int a, int b) { \
2883 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2884 wxString rval; \
2885 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2886 PyObject* ro; \
2887 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2888 if (ro) { \
2889 rval = Py2wxString(ro); \
2890 Py_DECREF(ro); \
2891 } \
2892 } \
2893 wxPyEndBlockThreads(blocked); \
2894 return rval; \
2895 }
2896
2897
2898 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2899 void CBNAME(int a, int b, const wxString& c) { \
2900 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2901 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2902 PyObject* s = wx2PyString(c); \
2903 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2904 Py_DECREF(s); \
2905 } \
2906 wxPyEndBlockThreads(blocked); \
2907 }
2908
2909
2910 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2911 wxString CBNAME(int a, int b) { \
2912 bool found; \
2913 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2914 wxString rval; \
2915 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2916 PyObject* ro; \
2917 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2918 if (ro) { \
2919 rval = Py2wxString(ro); \
2920 Py_DECREF(ro); \
2921 } \
2922 } \
2923 wxPyEndBlockThreads(blocked); \
2924 if (! found) \
2925 rval = PCLASS::CBNAME(a, b); \
2926 return rval; \
2927 }
2928
2929
2930 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2931 bool CBNAME(int a, int b, const wxString& c) { \
2932 bool rval = 0; \
2933 bool found; \
2934 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2935 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2936 PyObject* s = wx2PyString(c); \
2937 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2938 Py_DECREF(s); \
2939 } \
2940 wxPyEndBlockThreads(blocked); \
2941 if (! found) \
2942 rval = PCLASS::CBNAME(a,b,c); \
2943 return rval; \
2944 }
2945
2946
2947
2948
2949 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2950 long CBNAME(int a, int b) { \
2951 long rval; \
2952 bool found; \
2953 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2954 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2955 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2956 wxPyEndBlockThreads(blocked); \
2957 if (! found) \
2958 rval = PCLASS::CBNAME(a,b); \
2959 return rval; \
2960 }
2961
2962
2963 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2964 bool CBNAME(int a, int b) { \
2965 bool rval = 0; \
2966 bool found; \
2967 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2968 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2969 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2970 wxPyEndBlockThreads(blocked); \
2971 if (! found) \
2972 rval = PCLASS::CBNAME(a,b); \
2973 return rval; \
2974 }
2975
2976
2977
2978 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2979 double CBNAME(int a, int b) { \
2980 bool found; \
2981 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2982 double rval; \
2983 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2984 PyObject* ro; \
2985 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2986 if (ro) { \
2987 PyObject* str = PyObject_Str(ro); \
2988 rval = PyFloat_AsDouble(str); \
2989 Py_DECREF(ro); Py_DECREF(str); \
2990 } \
2991 } \
2992 wxPyEndBlockThreads(blocked); \
2993 if (! found) \
2994 rval = PCLASS::CBNAME(a, b); \
2995 return rval; \
2996 }
2997
2998
2999
3000 #define PYCALLBACK__(PCLASS, CBNAME) \
3001 void CBNAME() { \
3002 bool found; \
3003 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3004 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3005 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3006 wxPyEndBlockThreads(blocked); \
3007 if (! found) \
3008 PCLASS::CBNAME(); \
3009 }
3010
3011
3012
3013 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3014 bool CBNAME(size_t a, size_t b) { \
3015 bool rval = 0; \
3016 bool found; \
3017 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3018 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3019 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3020 wxPyEndBlockThreads(blocked); \
3021 if (! found) \
3022 rval = PCLASS::CBNAME(a,b); \
3023 return rval; \
3024 }
3025
3026
3027
3028 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3029 bool CBNAME(size_t a) { \
3030 bool rval = 0; \
3031 bool found; \
3032 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3033 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3034 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3035 wxPyEndBlockThreads(blocked); \
3036 if (! found) \
3037 rval = PCLASS::CBNAME(a); \
3038 return rval; \
3039 }
3040
3041
3042 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3043 wxString CBNAME(int a) { \
3044 bool found; \
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3046 wxString rval; \
3047 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3048 PyObject* ro; \
3049 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3050 if (ro) { \
3051 rval = Py2wxString(ro); \
3052 Py_DECREF(ro); \
3053 } \
3054 } \
3055 wxPyEndBlockThreads(blocked); \
3056 if (! found) \
3057 rval = PCLASS::CBNAME(a); \
3058 return rval; \
3059 }
3060
3061
3062 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3063 void CBNAME(int a, const wxString& c) { \
3064 bool found; \
3065 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3066 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3067 PyObject* s = wx2PyString(c); \
3068 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3069 Py_DECREF(s); \
3070 } \
3071 wxPyEndBlockThreads(blocked); \
3072 if (! found) \
3073 PCLASS::CBNAME(a,c); \
3074 }
3075
3076
3077
3078
3079 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3080 bool CBNAME() { \
3081 bool rval = 0; \
3082 bool found; \
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3084 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3085 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3086 wxPyEndBlockThreads(blocked); \
3087 if (! found) \
3088 rval = PCLASS::CBNAME(); \
3089 return rval; \
3090 }
3091
3092
3093
3094 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3095 void CBNAME(size_t a, int b) { \
3096 bool found; \
3097 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3098 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3099 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3100 wxPyEndBlockThreads(blocked); \
3101 if (! found) \
3102 PCLASS::CBNAME(a,b); \
3103 }
3104
3105
3106
3107
3108 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3109 void CBNAME(int a, int b, long c) { \
3110 bool found; \
3111 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3112 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3113 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3114 wxPyEndBlockThreads(blocked); \
3115 if (! found) \
3116 PCLASS::CBNAME(a,b,c); \
3117 }
3118
3119
3120
3121
3122 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3123 void CBNAME(int a, int b, double c) { \
3124 bool found; \
3125 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3126 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3127 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3128 wxPyEndBlockThreads(blocked); \
3129 if (! found) \
3130 PCLASS::CBNAME(a,b,c); \
3131 }
3132
3133
3134
3135 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3136 void CBNAME(int a, int b, bool c) { \
3137 bool found; \
3138 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3139 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3140 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3141 wxPyEndBlockThreads(blocked); \
3142 if (! found) \
3143 PCLASS::CBNAME(a,b,c); \
3144 }
3145
3146
3147
3148
3149
3150 SWIGINTERN swig_type_info*
3151 SWIG_pchar_descriptor()
3152 {
3153 static int init = 0;
3154 static swig_type_info* info = 0;
3155 if (!init) {
3156 info = SWIG_TypeQuery("_p_char");
3157 init = 1;
3158 }
3159 return info;
3160 }
3161
3162
3163 SWIGINTERNINLINE PyObject *
3164 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3165 {
3166 if (carray) {
3167 if (size > INT_MAX) {
3168 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3169 return pchar_descriptor ?
3170 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3171 } else {
3172 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3173 }
3174 } else {
3175 return SWIG_Py_Void();
3176 }
3177 }
3178
3179
3180 SWIGINTERNINLINE PyObject *
3181 SWIG_FromCharPtr(const char *cptr)
3182 {
3183 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3184 }
3185
3186
3187 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3188 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3189 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3190 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3191 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3192 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3193 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3194 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3195 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3196 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3197
3198
3199 #define SWIG_From_long PyInt_FromLong
3200
3201
3202 SWIGINTERNINLINE PyObject *
3203 SWIG_From_int (int value)
3204 {
3205 return SWIG_From_long (value);
3206 }
3207
3208 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3209 if (!self->GetClientObject())
3210 self->SetClientObject(new wxPyOORClientData(_self));
3211 }
3212 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3213 }
3214
3215 #include <limits.h>
3216 #ifndef LLONG_MIN
3217 # define LLONG_MIN LONG_LONG_MIN
3218 #endif
3219 #ifndef LLONG_MAX
3220 # define LLONG_MAX LONG_LONG_MAX
3221 #endif
3222 #ifndef ULLONG_MAX
3223 # define ULLONG_MAX ULONG_LONG_MAX
3224 #endif
3225
3226
3227 SWIGINTERN int
3228 SWIG_AsVal_long (PyObject* obj, long* val)
3229 {
3230 if (PyNumber_Check(obj)) {
3231 if (val) *val = PyInt_AsLong(obj);
3232 return SWIG_OK;
3233 }
3234 return SWIG_TypeError;
3235 }
3236
3237
3238 SWIGINTERN int
3239 SWIG_AsVal_int (PyObject * obj, int *val)
3240 {
3241 long v;
3242 int res = SWIG_AsVal_long (obj, &v);
3243 if (SWIG_IsOK(res)) {
3244 if ((v < INT_MIN || v > INT_MAX)) {
3245 return SWIG_OverflowError;
3246 } else {
3247 if (val) *val = static_cast< int >(v);
3248 }
3249 }
3250 return res;
3251 }
3252
3253
3254 SWIGINTERN int
3255 SWIG_AsVal_bool (PyObject *obj, bool *val)
3256 {
3257 if (obj == Py_True) {
3258 if (val) *val = true;
3259 return SWIG_OK;
3260 } else if (obj == Py_False) {
3261 if (val) *val = false;
3262 return SWIG_OK;
3263 } else {
3264 long v = 0;
3265 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3266 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3267 return res;
3268 }
3269 }
3270
3271
3272 class wxPyGridCellRenderer : public wxGridCellRenderer
3273 {
3274 public:
3275 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3276
3277 // Implement Python callback aware virtual methods
3278 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3279 wxDC& dc, const wxRect& rect,
3280 int row, int col, bool isSelected) {
3281 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3282 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3283 PyObject* go = wxPyMake_wxObject(&grid,false);
3284 PyObject* dco = wxPyMake_wxObject(&dc,false);
3285 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3286 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3287
3288 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3289 row, col, isSelected));
3290 Py_DECREF(go);
3291 Py_DECREF(ao);
3292 Py_DECREF(dco);
3293 Py_DECREF(ro);
3294 }
3295 wxPyEndBlockThreads(blocked);
3296 }
3297
3298 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3299 int row, int col) {
3300 wxSize rval;
3301 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3302 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3303 PyObject* ro;
3304 wxSize* ptr;
3305 PyObject* go = wxPyMake_wxObject(&grid,false);
3306 PyObject* dco = wxPyMake_wxObject(&dc,false);
3307 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3308
3309 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3310 go, ao, dco,
3311 row, col));
3312 Py_DECREF(go);
3313 Py_DECREF(ao);
3314 Py_DECREF(dco);
3315
3316 if (ro) {
3317 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3318 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3319 rval = *ptr;
3320 }
3321 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3322 PyObject* o1 = PySequence_GetItem(ro, 0);
3323 PyObject* o2 = PySequence_GetItem(ro, 1);
3324 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3325 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3326 else
3327 PyErr_SetString(PyExc_TypeError, errmsg);
3328 Py_DECREF(o1);
3329 Py_DECREF(o2);
3330 }
3331 else {
3332 PyErr_SetString(PyExc_TypeError, errmsg);
3333 }
3334 Py_DECREF(ro);
3335 }
3336 }
3337 wxPyEndBlockThreads(blocked);
3338 return rval;
3339 }
3340
3341
3342 wxGridCellRenderer *Clone() const {
3343 wxGridCellRenderer* rval = NULL;
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3346 PyObject* ro;
3347 wxGridCellRenderer* ptr;
3348 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3349 if (ro) {
3350 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3351 rval = ptr;
3352 Py_DECREF(ro);
3353 }
3354 }
3355 wxPyEndBlockThreads(blocked);
3356 return rval;
3357 }
3358
3359 DEC_PYCALLBACK__STRING(SetParameters);
3360
3361 PYPRIVATE;
3362 };
3363
3364 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3365
3366
3367
3368 class wxPyGridCellEditor : public wxGridCellEditor
3369 {
3370 public:
3371 wxPyGridCellEditor() : wxGridCellEditor() {}
3372
3373 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3374 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3375 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3376 PyObject* po = wxPyMake_wxObject(parent,false);
3377 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3378
3379 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3380 Py_DECREF(po);
3381 Py_DECREF(eo);
3382 }
3383 wxPyEndBlockThreads(blocked);
3384 }
3385
3386
3387 void BeginEdit(int row, int col, wxGrid* grid) {
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3390 PyObject* go = wxPyMake_wxObject(grid,false);
3391 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3392 Py_DECREF(go);
3393 }
3394 wxPyEndBlockThreads(blocked);
3395 }
3396
3397
3398 bool EndEdit(int row, int col, wxGrid* grid) {
3399 bool rv = false;
3400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3401 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3402 PyObject* go = wxPyMake_wxObject(grid,false);
3403 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3404 Py_DECREF(go);
3405 }
3406 wxPyEndBlockThreads(blocked);
3407 return rv;
3408 }
3409
3410
3411 wxGridCellEditor* Clone() const {
3412 wxGridCellEditor* rval = NULL;
3413 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3414 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3415 PyObject* ro;
3416 wxGridCellEditor* ptr;
3417 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3418 if (ro) {
3419 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3420 rval = ptr;
3421 Py_DECREF(ro);
3422 }
3423 }
3424 wxPyEndBlockThreads(blocked);
3425 return rval;
3426 }
3427
3428
3429 void Show(bool show, wxGridCellAttr *attr) {
3430 bool found;
3431 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3432 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3433 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3434 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3435 Py_DECREF(ao);
3436 }
3437 wxPyEndBlockThreads(blocked);
3438 if (! found)
3439 wxGridCellEditor::Show(show, attr);
3440 }
3441
3442
3443 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3444 bool found;
3445 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3446 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3447 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3448 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3449
3450 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3451
3452 Py_DECREF(ro);
3453 Py_DECREF(ao);
3454 }
3455 wxPyEndBlockThreads(blocked);
3456 if (! found)
3457 wxGridCellEditor::PaintBackground(rectCell, attr);
3458 }
3459
3460
3461 DEC_PYCALLBACK___pure(Reset);
3462 DEC_PYCALLBACK__constany(SetSize, wxRect);
3463 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3464 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3465 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3466 DEC_PYCALLBACK__(StartingClick);
3467 DEC_PYCALLBACK__(Destroy);
3468 DEC_PYCALLBACK__STRING(SetParameters);
3469 DEC_PYCALLBACK_STRING__constpure(GetValue);
3470
3471 PYPRIVATE;
3472 };
3473
3474
3475 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3476 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3477 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3478 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3479 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3480 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3481 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3482 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3483 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3484
3485
3486 static const wxString wxPyOneString(_T("1"));
3487 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3488 if (!self->GetClientObject())
3489 self->SetClientObject(new wxPyOORClientData(_self));
3490 }
3491 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3492 }
3493 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3494 if (!self->GetClientObject())
3495 self->SetClientObject(new wxPyOORClientData(_self));
3496 }
3497
3498 SWIGINTERN int
3499 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3500 {
3501 long v = 0;
3502 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3503 return SWIG_TypeError;
3504 }
3505 else if (val)
3506 *val = (unsigned long)v;
3507 return SWIG_OK;
3508 }
3509
3510
3511 SWIGINTERNINLINE int
3512 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3513 {
3514 unsigned long v;
3515 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3516 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3517 return res;
3518 }
3519
3520
3521 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3522 {
3523 public:
3524 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3525
3526 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3527 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3528 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3529 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3530
3531 PYPRIVATE;
3532 };
3533
3534 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3535 if (!self->GetClientObject())
3536 self->SetClientObject(new wxPyOORClientData(_self));
3537 }
3538
3539 #define SWIG_From_double PyFloat_FromDouble
3540
3541
3542 SWIGINTERN int
3543 SWIG_AsVal_double (PyObject *obj, double* val)
3544 {
3545 if (PyNumber_Check(obj)) {
3546 if (val) *val = PyFloat_AsDouble(obj);
3547 return SWIG_OK;
3548 }
3549 return SWIG_TypeError;
3550 }
3551
3552
3553 class wxPyGridTableBase : public wxGridTableBase
3554 {
3555 public:
3556 wxPyGridTableBase() : wxGridTableBase() {}
3557
3558 PYCALLBACK_INT__pure(GetNumberRows);
3559 PYCALLBACK_INT__pure(GetNumberCols);
3560 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3561 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3562 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3563 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3564 PYCALLBACK__(wxGridTableBase, Clear);
3565 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3566 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3567 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3568 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3569 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3570 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3571 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3572 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3573 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3574 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3575 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3576 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3577 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3578 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3579 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3580
3581
3582 wxString GetValue(int row, int col) {
3583 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3584 wxString rval;
3585 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3586 PyObject* ro;
3587 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3588 if (ro) {
3589 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3590 PyObject* old = ro;
3591 ro = PyObject_Str(ro);
3592 Py_DECREF(old);
3593 }
3594 rval = Py2wxString(ro);
3595 Py_DECREF(ro);
3596 }
3597 }
3598 wxPyEndBlockThreads(blocked);
3599 return rval;
3600 }
3601
3602 void SetValue(int row, int col, const wxString& val) {
3603 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3604 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3605 PyObject* s = wx2PyString(val);
3606 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3607 Py_DECREF(s);
3608 }
3609 wxPyEndBlockThreads(blocked);
3610 }
3611
3612
3613 // Map the Get/Set methods for the standard non-string types to
3614 // the GetValue and SetValue python methods.
3615 long GetValueAsLong( int row, int col ) {
3616 long rval = 0;
3617 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3618 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3619 PyObject* ro;
3620 PyObject* num;
3621 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3622 if (ro && PyNumber_Check(ro)) {
3623 num = PyNumber_Int(ro);
3624 if (num) {
3625 rval = PyInt_AsLong(num);
3626 Py_DECREF(num);
3627 }
3628 Py_DECREF(ro);
3629 }
3630 }
3631 wxPyEndBlockThreads(blocked);
3632 return rval;
3633 }
3634
3635 double GetValueAsDouble( int row, int col ) {
3636 double rval = 0.0;
3637 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3638 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3639 PyObject* ro;
3640 PyObject* num;
3641 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3642 if (ro && PyNumber_Check(ro)) {
3643 num = PyNumber_Float(ro);
3644 if (num) {
3645 rval = PyFloat_AsDouble(num);
3646 Py_DECREF(num);
3647 }
3648 Py_DECREF(ro);
3649 }
3650 }
3651 wxPyEndBlockThreads(blocked);
3652 return rval;
3653 }
3654
3655 bool GetValueAsBool( int row, int col ) {
3656 return (bool)GetValueAsLong(row, col);
3657 }
3658
3659 void SetValueAsLong( int row, int col, long value ) {
3660 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3661 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3662 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3663 }
3664 wxPyEndBlockThreads(blocked);
3665 }
3666
3667 void SetValueAsDouble( int row, int col, double value ) {
3668 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3669 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3670 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3671 }
3672 wxPyEndBlockThreads(blocked);
3673 }
3674
3675 void SetValueAsBool( int row, int col, bool value ) {
3676 SetValueAsLong( row, col, (long)value );
3677 }
3678
3679
3680 PYPRIVATE;
3681 };
3682
3683 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3684
3685 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3686
3687 if (source == Py_None) {
3688 **obj = wxGridCellCoords(-1,-1);
3689 return true;
3690 }
3691
3692 // If source is an object instance then it may already be the right type
3693 if (wxPySwigInstance_Check(source)) {
3694 wxGridCellCoords* ptr;
3695 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3696 goto error;
3697 *obj = ptr;
3698 return true;
3699 }
3700 // otherwise a 2-tuple of integers is expected
3701 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3702 PyObject* o1 = PySequence_GetItem(source, 0);
3703 PyObject* o2 = PySequence_GetItem(source, 1);
3704 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3705 Py_DECREF(o1);
3706 Py_DECREF(o2);
3707 goto error;
3708 }
3709 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3710 Py_DECREF(o1);
3711 Py_DECREF(o2);
3712 return true;
3713 }
3714
3715 error:
3716 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3717 return false;
3718 }
3719
3720
3721 bool wxGridCellCoords_typecheck(PyObject* source) {
3722 void* ptr;
3723
3724 if (wxPySwigInstance_Check(source) &&
3725 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3726 return true;
3727
3728 PyErr_Clear();
3729 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3730 return true;
3731
3732 return false;
3733 }
3734
3735
3736 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3737 {
3738 PyObject* list = PyList_New(0);
3739 size_t idx;
3740 for (idx = 0; idx < source.GetCount(); idx += 1) {
3741 wxGridCellCoords& coord = source.Item(idx);
3742 PyObject* tup = PyTuple_New(2);
3743 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3744 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3745 PyList_Append(list, tup);
3746 Py_DECREF(tup);
3747 }
3748 return list;
3749 }
3750
3751 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3752 wxGridCellCoords temp, *obj = &temp;
3753 if ( other == Py_None ) return false;
3754 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3755 PyErr_Clear();
3756 return false;
3757 }
3758 return self->operator==(*obj);
3759 }
3760 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3761 wxGridCellCoords temp, *obj = &temp;
3762 if ( other == Py_None ) return true;
3763 if ( ! wxGridCellCoords_helper(other, &obj)) {
3764 PyErr_Clear();
3765 return true;
3766 }
3767 return self->operator!=(*obj);
3768 }
3769 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3770 PyObject* tup = PyTuple_New(2);
3771 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3772 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3773 return tup;
3774 }
3775
3776 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3777
3778 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3779 wxGridCellCoords rv;
3780 self->XYToCell(x, y, rv);
3781 return rv;
3782 }
3783 #ifdef __cplusplus
3784 extern "C" {
3785 #endif
3786 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3787 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3788 return 1;
3789 }
3790
3791
3792 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3793 PyObject *pyobj = 0;
3794
3795 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3796 return pyobj;
3797 }
3798
3799
3800 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3801 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3802 return 1;
3803 }
3804
3805
3806 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3807 PyObject *pyobj = 0;
3808
3809 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3810 return pyobj;
3811 }
3812
3813
3814 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3815 PyObject *resultobj = 0;
3816 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3817 PyObject *arg2 = (PyObject *) 0 ;
3818 void *argp1 = 0 ;
3819 int res1 = 0 ;
3820 PyObject * obj0 = 0 ;
3821 PyObject * obj1 = 0 ;
3822 char * kwnames[] = {
3823 (char *) "self",(char *) "_self", NULL
3824 };
3825
3826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3828 if (!SWIG_IsOK(res1)) {
3829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3830 }
3831 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3832 arg2 = obj1;
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 wxGridCellWorker__setOORInfo(arg1,arg2);
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 resultobj = SWIG_Py_Void();
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3847 PyObject *resultobj = 0;
3848 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3849 void *argp1 = 0 ;
3850 int res1 = 0 ;
3851 PyObject *swig_obj[1] ;
3852
3853 if (!args) SWIG_fail;
3854 swig_obj[0] = args;
3855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3856 if (!SWIG_IsOK(res1)) {
3857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3858 }
3859 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3860 {
3861 PyThreadState* __tstate = wxPyBeginAllowThreads();
3862 delete_wxGridCellWorker(arg1);
3863
3864 wxPyEndAllowThreads(__tstate);
3865 if (PyErr_Occurred()) SWIG_fail;
3866 }
3867 resultobj = SWIG_Py_Void();
3868 return resultobj;
3869 fail:
3870 return NULL;
3871 }
3872
3873
3874 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3875 PyObject *resultobj = 0;
3876 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3877 wxString *arg2 = 0 ;
3878 void *argp1 = 0 ;
3879 int res1 = 0 ;
3880 bool temp2 = false ;
3881 PyObject * obj0 = 0 ;
3882 PyObject * obj1 = 0 ;
3883 char * kwnames[] = {
3884 (char *) "self",(char *) "params", NULL
3885 };
3886
3887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3889 if (!SWIG_IsOK(res1)) {
3890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3891 }
3892 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3893 {
3894 arg2 = wxString_in_helper(obj1);
3895 if (arg2 == NULL) SWIG_fail;
3896 temp2 = true;
3897 }
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 (arg1)->SetParameters((wxString const &)*arg2);
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 resultobj = SWIG_Py_Void();
3905 {
3906 if (temp2)
3907 delete arg2;
3908 }
3909 return resultobj;
3910 fail:
3911 {
3912 if (temp2)
3913 delete arg2;
3914 }
3915 return NULL;
3916 }
3917
3918
3919 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3920 PyObject *resultobj = 0;
3921 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3922 void *argp1 = 0 ;
3923 int res1 = 0 ;
3924 PyObject *swig_obj[1] ;
3925
3926 if (!args) SWIG_fail;
3927 swig_obj[0] = args;
3928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3929 if (!SWIG_IsOK(res1)) {
3930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3931 }
3932 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3933 {
3934 PyThreadState* __tstate = wxPyBeginAllowThreads();
3935 (arg1)->IncRef();
3936 wxPyEndAllowThreads(__tstate);
3937 if (PyErr_Occurred()) SWIG_fail;
3938 }
3939 resultobj = SWIG_Py_Void();
3940 return resultobj;
3941 fail:
3942 return NULL;
3943 }
3944
3945
3946 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3947 PyObject *resultobj = 0;
3948 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3949 void *argp1 = 0 ;
3950 int res1 = 0 ;
3951 PyObject *swig_obj[1] ;
3952
3953 if (!args) SWIG_fail;
3954 swig_obj[0] = args;
3955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3956 if (!SWIG_IsOK(res1)) {
3957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3958 }
3959 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 (arg1)->DecRef();
3963 wxPyEndAllowThreads(__tstate);
3964 if (PyErr_Occurred()) SWIG_fail;
3965 }
3966 resultobj = SWIG_Py_Void();
3967 return resultobj;
3968 fail:
3969 return NULL;
3970 }
3971
3972
3973 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3974 PyObject *obj;
3975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3976 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3977 return SWIG_Py_Void();
3978 }
3979
3980 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj = 0;
3982 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3983 wxGrid *arg2 = 0 ;
3984 wxGridCellAttr *arg3 = 0 ;
3985 wxDC *arg4 = 0 ;
3986 wxRect *arg5 = 0 ;
3987 int arg6 ;
3988 int arg7 ;
3989 bool arg8 ;
3990 void *argp1 = 0 ;
3991 int res1 = 0 ;
3992 void *argp2 = 0 ;
3993 int res2 = 0 ;
3994 void *argp3 = 0 ;
3995 int res3 = 0 ;
3996 void *argp4 = 0 ;
3997 int res4 = 0 ;
3998 wxRect temp5 ;
3999 int val6 ;
4000 int ecode6 = 0 ;
4001 int val7 ;
4002 int ecode7 = 0 ;
4003 bool val8 ;
4004 int ecode8 = 0 ;
4005 PyObject * obj0 = 0 ;
4006 PyObject * obj1 = 0 ;
4007 PyObject * obj2 = 0 ;
4008 PyObject * obj3 = 0 ;
4009 PyObject * obj4 = 0 ;
4010 PyObject * obj5 = 0 ;
4011 PyObject * obj6 = 0 ;
4012 PyObject * obj7 = 0 ;
4013 char * kwnames[] = {
4014 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4015 };
4016
4017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4019 if (!SWIG_IsOK(res1)) {
4020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4021 }
4022 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4023 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4024 if (!SWIG_IsOK(res2)) {
4025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4026 }
4027 if (!argp2) {
4028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4029 }
4030 arg2 = reinterpret_cast< wxGrid * >(argp2);
4031 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4032 if (!SWIG_IsOK(res3)) {
4033 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4034 }
4035 if (!argp3) {
4036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4037 }
4038 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4039 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4040 if (!SWIG_IsOK(res4)) {
4041 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4042 }
4043 if (!argp4) {
4044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4045 }
4046 arg4 = reinterpret_cast< wxDC * >(argp4);
4047 {
4048 arg5 = &temp5;
4049 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4050 }
4051 ecode6 = SWIG_AsVal_int(obj5, &val6);
4052 if (!SWIG_IsOK(ecode6)) {
4053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4054 }
4055 arg6 = static_cast< int >(val6);
4056 ecode7 = SWIG_AsVal_int(obj6, &val7);
4057 if (!SWIG_IsOK(ecode7)) {
4058 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4059 }
4060 arg7 = static_cast< int >(val7);
4061 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4062 if (!SWIG_IsOK(ecode8)) {
4063 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4064 }
4065 arg8 = static_cast< bool >(val8);
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 resultobj = SWIG_Py_Void();
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
4079 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj = 0;
4081 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4082 wxGrid *arg2 = 0 ;
4083 wxGridCellAttr *arg3 = 0 ;
4084 wxDC *arg4 = 0 ;
4085 int arg5 ;
4086 int arg6 ;
4087 wxSize result;
4088 void *argp1 = 0 ;
4089 int res1 = 0 ;
4090 void *argp2 = 0 ;
4091 int res2 = 0 ;
4092 void *argp3 = 0 ;
4093 int res3 = 0 ;
4094 void *argp4 = 0 ;
4095 int res4 = 0 ;
4096 int val5 ;
4097 int ecode5 = 0 ;
4098 int val6 ;
4099 int ecode6 = 0 ;
4100 PyObject * obj0 = 0 ;
4101 PyObject * obj1 = 0 ;
4102 PyObject * obj2 = 0 ;
4103 PyObject * obj3 = 0 ;
4104 PyObject * obj4 = 0 ;
4105 PyObject * obj5 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4112 if (!SWIG_IsOK(res1)) {
4113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4114 }
4115 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4117 if (!SWIG_IsOK(res2)) {
4118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4119 }
4120 if (!argp2) {
4121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4122 }
4123 arg2 = reinterpret_cast< wxGrid * >(argp2);
4124 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4125 if (!SWIG_IsOK(res3)) {
4126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4127 }
4128 if (!argp3) {
4129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4130 }
4131 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4132 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4133 if (!SWIG_IsOK(res4)) {
4134 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4135 }
4136 if (!argp4) {
4137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4138 }
4139 arg4 = reinterpret_cast< wxDC * >(argp4);
4140 ecode5 = SWIG_AsVal_int(obj4, &val5);
4141 if (!SWIG_IsOK(ecode5)) {
4142 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4143 }
4144 arg5 = static_cast< int >(val5);
4145 ecode6 = SWIG_AsVal_int(obj5, &val6);
4146 if (!SWIG_IsOK(ecode6)) {
4147 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4148 }
4149 arg6 = static_cast< int >(val6);
4150 {
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4164 PyObject *resultobj = 0;
4165 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4166 wxGridCellRenderer *result = 0 ;
4167 void *argp1 = 0 ;
4168 int res1 = 0 ;
4169 PyObject *swig_obj[1] ;
4170
4171 if (!args) SWIG_fail;
4172 swig_obj[0] = args;
4173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4174 if (!SWIG_IsOK(res1)) {
4175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4176 }
4177 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4178 {
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 {
4185 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4186 }
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4194 PyObject *obj;
4195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4196 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4197 return SWIG_Py_Void();
4198 }
4199
4200 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4201 PyObject *resultobj = 0;
4202 wxPyGridCellRenderer *result = 0 ;
4203
4204 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4212 return resultobj;
4213 fail:
4214 return NULL;
4215 }
4216
4217
4218 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4219 PyObject *resultobj = 0;
4220 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4221 PyObject *arg2 = (PyObject *) 0 ;
4222 PyObject *arg3 = (PyObject *) 0 ;
4223 void *argp1 = 0 ;
4224 int res1 = 0 ;
4225 PyObject * obj0 = 0 ;
4226 PyObject * obj1 = 0 ;
4227 PyObject * obj2 = 0 ;
4228 char * kwnames[] = {
4229 (char *) "self",(char *) "self",(char *) "_class", NULL
4230 };
4231
4232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4234 if (!SWIG_IsOK(res1)) {
4235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4236 }
4237 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4238 arg2 = obj1;
4239 arg3 = obj2;
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 (arg1)->_setCallbackInfo(arg2,arg3);
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 resultobj = SWIG_Py_Void();
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj = 0;
4255 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4256 wxString *arg2 = 0 ;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 bool temp2 = false ;
4260 PyObject * obj0 = 0 ;
4261 PyObject * obj1 = 0 ;
4262 char * kwnames[] = {
4263 (char *) "self",(char *) "params", NULL
4264 };
4265
4266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4268 if (!SWIG_IsOK(res1)) {
4269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4270 }
4271 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4272 {
4273 arg2 = wxString_in_helper(obj1);
4274 if (arg2 == NULL) SWIG_fail;
4275 temp2 = true;
4276 }
4277 {
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 (arg1)->SetParameters((wxString const &)*arg2);
4280 wxPyEndAllowThreads(__tstate);
4281 if (PyErr_Occurred()) SWIG_fail;
4282 }
4283 resultobj = SWIG_Py_Void();
4284 {
4285 if (temp2)
4286 delete arg2;
4287 }
4288 return resultobj;
4289 fail:
4290 {
4291 if (temp2)
4292 delete arg2;
4293 }
4294 return NULL;
4295 }
4296
4297
4298 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4299 PyObject *obj;
4300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4301 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4302 return SWIG_Py_Void();
4303 }
4304
4305 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4306 return SWIG_Python_InitShadowInstance(args);
4307 }
4308
4309 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4310 PyObject *resultobj = 0;
4311 wxGridCellStringRenderer *result = 0 ;
4312
4313 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4314 {
4315 PyThreadState* __tstate = wxPyBeginAllowThreads();
4316 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4317 wxPyEndAllowThreads(__tstate);
4318 if (PyErr_Occurred()) SWIG_fail;
4319 }
4320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4328 PyObject *obj;
4329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4330 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4331 return SWIG_Py_Void();
4332 }
4333
4334 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4335 return SWIG_Python_InitShadowInstance(args);
4336 }
4337
4338 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4339 PyObject *resultobj = 0;
4340 wxGridCellNumberRenderer *result = 0 ;
4341
4342 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4343 {
4344 PyThreadState* __tstate = wxPyBeginAllowThreads();
4345 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4346 wxPyEndAllowThreads(__tstate);
4347 if (PyErr_Occurred()) SWIG_fail;
4348 }
4349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4357 PyObject *obj;
4358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4359 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4360 return SWIG_Py_Void();
4361 }
4362
4363 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4364 return SWIG_Python_InitShadowInstance(args);
4365 }
4366
4367 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4368 PyObject *resultobj = 0;
4369 int arg1 = (int) -1 ;
4370 int arg2 = (int) -1 ;
4371 wxGridCellFloatRenderer *result = 0 ;
4372 int val1 ;
4373 int ecode1 = 0 ;
4374 int val2 ;
4375 int ecode2 = 0 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char * kwnames[] = {
4379 (char *) "width",(char *) "precision", NULL
4380 };
4381
4382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4383 if (obj0) {
4384 ecode1 = SWIG_AsVal_int(obj0, &val1);
4385 if (!SWIG_IsOK(ecode1)) {
4386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4387 }
4388 arg1 = static_cast< int >(val1);
4389 }
4390 if (obj1) {
4391 ecode2 = SWIG_AsVal_int(obj1, &val2);
4392 if (!SWIG_IsOK(ecode2)) {
4393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4394 }
4395 arg2 = static_cast< int >(val2);
4396 }
4397 {
4398 PyThreadState* __tstate = wxPyBeginAllowThreads();
4399 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4404 return resultobj;
4405 fail:
4406 return NULL;
4407 }
4408
4409
4410 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4411 PyObject *resultobj = 0;
4412 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4413 int result;
4414 void *argp1 = 0 ;
4415 int res1 = 0 ;
4416 PyObject *swig_obj[1] ;
4417
4418 if (!args) SWIG_fail;
4419 swig_obj[0] = args;
4420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4421 if (!SWIG_IsOK(res1)) {
4422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4423 }
4424 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4425 {
4426 PyThreadState* __tstate = wxPyBeginAllowThreads();
4427 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4428 wxPyEndAllowThreads(__tstate);
4429 if (PyErr_Occurred()) SWIG_fail;
4430 }
4431 resultobj = SWIG_From_int(static_cast< int >(result));
4432 return resultobj;
4433 fail:
4434 return NULL;
4435 }
4436
4437
4438 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4439 PyObject *resultobj = 0;
4440 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4441 int arg2 ;
4442 void *argp1 = 0 ;
4443 int res1 = 0 ;
4444 int val2 ;
4445 int ecode2 = 0 ;
4446 PyObject * obj0 = 0 ;
4447 PyObject * obj1 = 0 ;
4448 char * kwnames[] = {
4449 (char *) "self",(char *) "width", NULL
4450 };
4451
4452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4454 if (!SWIG_IsOK(res1)) {
4455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4456 }
4457 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4458 ecode2 = SWIG_AsVal_int(obj1, &val2);
4459 if (!SWIG_IsOK(ecode2)) {
4460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4461 }
4462 arg2 = static_cast< int >(val2);
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 (arg1)->SetWidth(arg2);
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *resultobj = 0;
4478 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4479 int result;
4480 void *argp1 = 0 ;
4481 int res1 = 0 ;
4482 PyObject *swig_obj[1] ;
4483
4484 if (!args) SWIG_fail;
4485 swig_obj[0] = args;
4486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4487 if (!SWIG_IsOK(res1)) {
4488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4489 }
4490 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 resultobj = SWIG_From_int(static_cast< int >(result));
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4505 PyObject *resultobj = 0;
4506 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4507 int arg2 ;
4508 void *argp1 = 0 ;
4509 int res1 = 0 ;
4510 int val2 ;
4511 int ecode2 = 0 ;
4512 PyObject * obj0 = 0 ;
4513 PyObject * obj1 = 0 ;
4514 char * kwnames[] = {
4515 (char *) "self",(char *) "precision", NULL
4516 };
4517
4518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4520 if (!SWIG_IsOK(res1)) {
4521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4522 }
4523 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4524 ecode2 = SWIG_AsVal_int(obj1, &val2);
4525 if (!SWIG_IsOK(ecode2)) {
4526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4527 }
4528 arg2 = static_cast< int >(val2);
4529 {
4530 PyThreadState* __tstate = wxPyBeginAllowThreads();
4531 (arg1)->SetPrecision(arg2);
4532 wxPyEndAllowThreads(__tstate);
4533 if (PyErr_Occurred()) SWIG_fail;
4534 }
4535 resultobj = SWIG_Py_Void();
4536 return resultobj;
4537 fail:
4538 return NULL;
4539 }
4540
4541
4542 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4543 PyObject *obj;
4544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4545 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4546 return SWIG_Py_Void();
4547 }
4548
4549 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 return SWIG_Python_InitShadowInstance(args);
4551 }
4552
4553 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 wxGridCellBoolRenderer *result = 0 ;
4556
4557 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4572 PyObject *obj;
4573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4574 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4575 return SWIG_Py_Void();
4576 }
4577
4578 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4579 return SWIG_Python_InitShadowInstance(args);
4580 }
4581
4582 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4583 PyObject *resultobj = 0;
4584 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4585 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4586 wxGridCellDateTimeRenderer *result = 0 ;
4587 PyObject * obj0 = 0 ;
4588 PyObject * obj1 = 0 ;
4589 char * kwnames[] = {
4590 (char *) "outformat",(char *) "informat", NULL
4591 };
4592
4593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4594 if (obj0) {
4595 {
4596 wxString* sptr = wxString_in_helper(obj0);
4597 if (sptr == NULL) SWIG_fail;
4598 arg1 = *sptr;
4599 delete sptr;
4600 }
4601 }
4602 if (obj1) {
4603 {
4604 wxString* sptr = wxString_in_helper(obj1);
4605 if (sptr == NULL) SWIG_fail;
4606 arg2 = *sptr;
4607 delete sptr;
4608 }
4609 }
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4624 PyObject *obj;
4625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4626 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4627 return SWIG_Py_Void();
4628 }
4629
4630 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 return SWIG_Python_InitShadowInstance(args);
4632 }
4633
4634 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj = 0;
4636 wxString const &arg1_defvalue = wxPyEmptyString ;
4637 wxString *arg1 = (wxString *) &arg1_defvalue ;
4638 wxGridCellEnumRenderer *result = 0 ;
4639 bool temp1 = false ;
4640 PyObject * obj0 = 0 ;
4641 char * kwnames[] = {
4642 (char *) "choices", NULL
4643 };
4644
4645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4646 if (obj0) {
4647 {
4648 arg1 = wxString_in_helper(obj0);
4649 if (arg1 == NULL) SWIG_fail;
4650 temp1 = true;
4651 }
4652 }
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4660 {
4661 if (temp1)
4662 delete arg1;
4663 }
4664 return resultobj;
4665 fail:
4666 {
4667 if (temp1)
4668 delete arg1;
4669 }
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4675 PyObject *obj;
4676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4677 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4678 return SWIG_Py_Void();
4679 }
4680
4681 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4682 return SWIG_Python_InitShadowInstance(args);
4683 }
4684
4685 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4686 PyObject *resultobj = 0;
4687 wxGridCellAutoWrapStringRenderer *result = 0 ;
4688
4689 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *obj;
4705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4706 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4707 return SWIG_Py_Void();
4708 }
4709
4710 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4711 return SWIG_Python_InitShadowInstance(args);
4712 }
4713
4714 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4715 PyObject *resultobj = 0;
4716 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4717 bool result;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 PyObject *swig_obj[1] ;
4721
4722 if (!args) SWIG_fail;
4723 swig_obj[0] = args;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4727 }
4728 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4729 {
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = (bool)(arg1)->IsCreated();
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4737 }
4738 return resultobj;
4739 fail:
4740 return NULL;
4741 }
4742
4743
4744 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4745 PyObject *resultobj = 0;
4746 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4747 wxControl *result = 0 ;
4748 void *argp1 = 0 ;
4749 int res1 = 0 ;
4750 PyObject *swig_obj[1] ;
4751
4752 if (!args) SWIG_fail;
4753 swig_obj[0] = args;
4754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4755 if (!SWIG_IsOK(res1)) {
4756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4757 }
4758 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4759 {
4760 PyThreadState* __tstate = wxPyBeginAllowThreads();
4761 result = (wxControl *)(arg1)->GetControl();
4762 wxPyEndAllowThreads(__tstate);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 {
4766 resultobj = wxPyMake_wxObject(result, 0);
4767 }
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4777 wxControl *arg2 = (wxControl *) 0 ;
4778 void *argp1 = 0 ;
4779 int res1 = 0 ;
4780 void *argp2 = 0 ;
4781 int res2 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "self",(char *) "control", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4792 }
4793 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4795 if (!SWIG_IsOK(res2)) {
4796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4797 }
4798 arg2 = reinterpret_cast< wxControl * >(argp2);
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 (arg1)->SetControl(arg2);
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 resultobj = SWIG_Py_Void();
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4813 PyObject *resultobj = 0;
4814 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4815 wxGridCellAttr *result = 0 ;
4816 void *argp1 = 0 ;
4817 int res1 = 0 ;
4818 PyObject *swig_obj[1] ;
4819
4820 if (!args) SWIG_fail;
4821 swig_obj[0] = args;
4822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4825 }
4826 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4827 {
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 {
4834 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4835 }
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
4842 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj = 0;
4844 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4845 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4846 void *argp1 = 0 ;
4847 int res1 = 0 ;
4848 void *argp2 = 0 ;
4849 int res2 = 0 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 char * kwnames[] = {
4853 (char *) "self",(char *) "attr", NULL
4854 };
4855
4856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4860 }
4861 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4863 if (!SWIG_IsOK(res2)) {
4864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4865 }
4866 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4867 {
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 (arg1)->SetCellAttr(arg2);
4870 wxPyEndAllowThreads(__tstate);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 resultobj = SWIG_Py_Void();
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj = 0;
4882 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4883 wxWindow *arg2 = (wxWindow *) 0 ;
4884 int arg3 ;
4885 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4886 void *argp1 = 0 ;
4887 int res1 = 0 ;
4888 void *argp2 = 0 ;
4889 int res2 = 0 ;
4890 int val3 ;
4891 int ecode3 = 0 ;
4892 void *argp4 = 0 ;
4893 int res4 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 PyObject * obj1 = 0 ;
4896 PyObject * obj2 = 0 ;
4897 PyObject * obj3 = 0 ;
4898 char * kwnames[] = {
4899 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4900 };
4901
4902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4904 if (!SWIG_IsOK(res1)) {
4905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4906 }
4907 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4909 if (!SWIG_IsOK(res2)) {
4910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4911 }
4912 arg2 = reinterpret_cast< wxWindow * >(argp2);
4913 ecode3 = SWIG_AsVal_int(obj2, &val3);
4914 if (!SWIG_IsOK(ecode3)) {
4915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4916 }
4917 arg3 = static_cast< int >(val3);
4918 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4919 if (!SWIG_IsOK(res4)) {
4920 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4921 }
4922 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4923 {
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 (arg1)->Create(arg2,arg3,arg4);
4926 wxPyEndAllowThreads(__tstate);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 resultobj = SWIG_Py_Void();
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj = 0;
4938 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4939 int arg2 ;
4940 int arg3 ;
4941 wxGrid *arg4 = (wxGrid *) 0 ;
4942 void *argp1 = 0 ;
4943 int res1 = 0 ;
4944 int val2 ;
4945 int ecode2 = 0 ;
4946 int val3 ;
4947 int ecode3 = 0 ;
4948 void *argp4 = 0 ;
4949 int res4 = 0 ;
4950 PyObject * obj0 = 0 ;
4951 PyObject * obj1 = 0 ;
4952 PyObject * obj2 = 0 ;
4953 PyObject * obj3 = 0 ;
4954 char * kwnames[] = {
4955 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4956 };
4957
4958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4960 if (!SWIG_IsOK(res1)) {
4961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4962 }
4963 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4964 ecode2 = SWIG_AsVal_int(obj1, &val2);
4965 if (!SWIG_IsOK(ecode2)) {
4966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4967 }
4968 arg2 = static_cast< int >(val2);
4969 ecode3 = SWIG_AsVal_int(obj2, &val3);
4970 if (!SWIG_IsOK(ecode3)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4972 }
4973 arg3 = static_cast< int >(val3);
4974 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4975 if (!SWIG_IsOK(res4)) {
4976 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4977 }
4978 arg4 = reinterpret_cast< wxGrid * >(argp4);
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 (arg1)->BeginEdit(arg2,arg3,arg4);
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 resultobj = SWIG_Py_Void();
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj = 0;
4994 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4995 int arg2 ;
4996 int arg3 ;
4997 wxGrid *arg4 = (wxGrid *) 0 ;
4998 bool result;
4999 void *argp1 = 0 ;
5000 int res1 = 0 ;
5001 int val2 ;
5002 int ecode2 = 0 ;
5003 int val3 ;
5004 int ecode3 = 0 ;
5005 void *argp4 = 0 ;
5006 int res4 = 0 ;
5007 PyObject * obj0 = 0 ;
5008 PyObject * obj1 = 0 ;
5009 PyObject * obj2 = 0 ;
5010 PyObject * obj3 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5019 }
5020 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 ecode3 = SWIG_AsVal_int(obj2, &val3);
5027 if (!SWIG_IsOK(ecode3)) {
5028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5029 }
5030 arg3 = static_cast< int >(val3);
5031 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5032 if (!SWIG_IsOK(res4)) {
5033 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5034 }
5035 arg4 = reinterpret_cast< wxGrid * >(argp4);
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5044 }
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5052 PyObject *resultobj = 0;
5053 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5054 void *argp1 = 0 ;
5055 int res1 = 0 ;
5056 PyObject *swig_obj[1] ;
5057
5058 if (!args) SWIG_fail;
5059 swig_obj[0] = args;
5060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5061 if (!SWIG_IsOK(res1)) {
5062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5063 }
5064 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5065 {
5066 PyThreadState* __tstate = wxPyBeginAllowThreads();
5067 (arg1)->Reset();
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 resultobj = SWIG_Py_Void();
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5079 PyObject *resultobj = 0;
5080 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5081 wxGridCellEditor *result = 0 ;
5082 void *argp1 = 0 ;
5083 int res1 = 0 ;
5084 PyObject *swig_obj[1] ;
5085
5086 if (!args) SWIG_fail;
5087 swig_obj[0] = args;
5088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5089 if (!SWIG_IsOK(res1)) {
5090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5091 }
5092 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5093 {
5094 PyThreadState* __tstate = wxPyBeginAllowThreads();
5095 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 {
5100 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5101 }
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5109 PyObject *resultobj = 0;
5110 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5111 wxRect *arg2 = 0 ;
5112 void *argp1 = 0 ;
5113 int res1 = 0 ;
5114 wxRect temp2 ;
5115 PyObject * obj0 = 0 ;
5116 PyObject * obj1 = 0 ;
5117 char * kwnames[] = {
5118 (char *) "self",(char *) "rect", NULL
5119 };
5120
5121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5123 if (!SWIG_IsOK(res1)) {
5124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5125 }
5126 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5127 {
5128 arg2 = &temp2;
5129 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5130 }
5131 {
5132 PyThreadState* __tstate = wxPyBeginAllowThreads();
5133 (arg1)->SetSize((wxRect const &)*arg2);
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 resultobj = SWIG_Py_Void();
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj = 0;
5146 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5147 bool arg2 ;
5148 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5149 void *argp1 = 0 ;
5150 int res1 = 0 ;
5151 bool val2 ;
5152 int ecode2 = 0 ;
5153 void *argp3 = 0 ;
5154 int res3 = 0 ;
5155 PyObject * obj0 = 0 ;
5156 PyObject * obj1 = 0 ;
5157 PyObject * obj2 = 0 ;
5158 char * kwnames[] = {
5159 (char *) "self",(char *) "show",(char *) "attr", NULL
5160 };
5161
5162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5164 if (!SWIG_IsOK(res1)) {
5165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5166 }
5167 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5169 if (!SWIG_IsOK(ecode2)) {
5170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5171 }
5172 arg2 = static_cast< bool >(val2);
5173 if (obj2) {
5174 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5175 if (!SWIG_IsOK(res3)) {
5176 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5177 }
5178 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5179 }
5180 {
5181 PyThreadState* __tstate = wxPyBeginAllowThreads();
5182 (arg1)->Show(arg2,arg3);
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_Py_Void();
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj = 0;
5195 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5196 wxRect *arg2 = 0 ;
5197 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5198 void *argp1 = 0 ;
5199 int res1 = 0 ;
5200 wxRect temp2 ;
5201 void *argp3 = 0 ;
5202 int res3 = 0 ;
5203 PyObject * obj0 = 0 ;
5204 PyObject * obj1 = 0 ;
5205 PyObject * obj2 = 0 ;
5206 char * kwnames[] = {
5207 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5208 };
5209
5210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5214 }
5215 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5216 {
5217 arg2 = &temp2;
5218 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5219 }
5220 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5221 if (!SWIG_IsOK(res3)) {
5222 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5223 }
5224 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5225 {
5226 PyThreadState* __tstate = wxPyBeginAllowThreads();
5227 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5228 wxPyEndAllowThreads(__tstate);
5229 if (PyErr_Occurred()) SWIG_fail;
5230 }
5231 resultobj = SWIG_Py_Void();
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5239 PyObject *resultobj = 0;
5240 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5241 wxKeyEvent *arg2 = 0 ;
5242 bool result;
5243 void *argp1 = 0 ;
5244 int res1 = 0 ;
5245 void *argp2 = 0 ;
5246 int res2 = 0 ;
5247 PyObject * obj0 = 0 ;
5248 PyObject * obj1 = 0 ;
5249 char * kwnames[] = {
5250 (char *) "self",(char *) "event", NULL
5251 };
5252
5253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5255 if (!SWIG_IsOK(res1)) {
5256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5257 }
5258 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5259 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5260 if (!SWIG_IsOK(res2)) {
5261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5262 }
5263 if (!argp2) {
5264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5265 }
5266 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5267 {
5268 PyThreadState* __tstate = wxPyBeginAllowThreads();
5269 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj = 0;
5284 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5285 wxKeyEvent *arg2 = 0 ;
5286 void *argp1 = 0 ;
5287 int res1 = 0 ;
5288 void *argp2 = 0 ;
5289 int res2 = 0 ;
5290 PyObject * obj0 = 0 ;
5291 PyObject * obj1 = 0 ;
5292 char * kwnames[] = {
5293 (char *) "self",(char *) "event", NULL
5294 };
5295
5296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5298 if (!SWIG_IsOK(res1)) {
5299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5300 }
5301 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5302 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5303 if (!SWIG_IsOK(res2)) {
5304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5305 }
5306 if (!argp2) {
5307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5308 }
5309 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 (arg1)->StartingKey(*arg2);
5313 wxPyEndAllowThreads(__tstate);
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 resultobj = SWIG_Py_Void();
5317 return resultobj;
5318 fail:
5319 return NULL;
5320 }
5321
5322
5323 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5324 PyObject *resultobj = 0;
5325 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5326 void *argp1 = 0 ;
5327 int res1 = 0 ;
5328 PyObject *swig_obj[1] ;
5329
5330 if (!args) SWIG_fail;
5331 swig_obj[0] = args;
5332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5333 if (!SWIG_IsOK(res1)) {
5334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5335 }
5336 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 (arg1)->StartingClick();
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_Py_Void();
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5351 PyObject *resultobj = 0;
5352 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5353 wxKeyEvent *arg2 = 0 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 void *argp2 = 0 ;
5357 int res2 = 0 ;
5358 PyObject * obj0 = 0 ;
5359 PyObject * obj1 = 0 ;
5360 char * kwnames[] = {
5361 (char *) "self",(char *) "event", NULL
5362 };
5363
5364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5368 }
5369 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5371 if (!SWIG_IsOK(res2)) {
5372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5373 }
5374 if (!argp2) {
5375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5376 }
5377 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 (arg1)->HandleReturn(*arg2);
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 resultobj = SWIG_Py_Void();
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5392 PyObject *resultobj = 0;
5393 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5394 void *argp1 = 0 ;
5395 int res1 = 0 ;
5396 PyObject *swig_obj[1] ;
5397
5398 if (!args) SWIG_fail;
5399 swig_obj[0] = args;
5400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5401 if (!SWIG_IsOK(res1)) {
5402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5403 }
5404 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 (arg1)->Destroy();
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 resultobj = SWIG_Py_Void();
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5419 PyObject *obj;
5420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5421 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5422 return SWIG_Py_Void();
5423 }
5424
5425 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5426 PyObject *resultobj = 0;
5427 wxPyGridCellEditor *result = 0 ;
5428
5429 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5433 wxPyEndAllowThreads(__tstate);
5434 if (PyErr_Occurred()) SWIG_fail;
5435 }
5436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj = 0;
5445 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5446 PyObject *arg2 = (PyObject *) 0 ;
5447 PyObject *arg3 = (PyObject *) 0 ;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 PyObject * obj0 = 0 ;
5451 PyObject * obj1 = 0 ;
5452 PyObject * obj2 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "self",(char *) "_class", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5461 }
5462 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5463 arg2 = obj1;
5464 arg3 = obj2;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 (arg1)->_setCallbackInfo(arg2,arg3);
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 resultobj = SWIG_Py_Void();
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj = 0;
5480 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5481 wxString *arg2 = 0 ;
5482 void *argp1 = 0 ;
5483 int res1 = 0 ;
5484 bool temp2 = false ;
5485 PyObject * obj0 = 0 ;
5486 PyObject * obj1 = 0 ;
5487 char * kwnames[] = {
5488 (char *) "self",(char *) "params", NULL
5489 };
5490
5491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5493 if (!SWIG_IsOK(res1)) {
5494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5495 }
5496 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5497 {
5498 arg2 = wxString_in_helper(obj1);
5499 if (arg2 == NULL) SWIG_fail;
5500 temp2 = true;
5501 }
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 (arg1)->SetParameters((wxString const &)*arg2);
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 resultobj = SWIG_Py_Void();
5509 {
5510 if (temp2)
5511 delete arg2;
5512 }
5513 return resultobj;
5514 fail:
5515 {
5516 if (temp2)
5517 delete arg2;
5518 }
5519 return NULL;
5520 }
5521
5522
5523 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5524 PyObject *obj;
5525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5526 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5527 return SWIG_Py_Void();
5528 }
5529
5530 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5531 return SWIG_Python_InitShadowInstance(args);
5532 }
5533
5534 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5535 PyObject *resultobj = 0;
5536 wxGridCellTextEditor *result = 0 ;
5537
5538 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5553 PyObject *resultobj = 0;
5554 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5555 wxString result;
5556 void *argp1 = 0 ;
5557 int res1 = 0 ;
5558 PyObject *swig_obj[1] ;
5559
5560 if (!args) SWIG_fail;
5561 swig_obj[0] = args;
5562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5563 if (!SWIG_IsOK(res1)) {
5564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5565 }
5566 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (arg1)->GetValue();
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 {
5574 #if wxUSE_UNICODE
5575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5576 #else
5577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5578 #endif
5579 }
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5587 PyObject *obj;
5588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5589 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5590 return SWIG_Py_Void();
5591 }
5592
5593 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 return SWIG_Python_InitShadowInstance(args);
5595 }
5596
5597 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj = 0;
5599 int arg1 = (int) -1 ;
5600 int arg2 = (int) -1 ;
5601 wxGridCellNumberEditor *result = 0 ;
5602 int val1 ;
5603 int ecode1 = 0 ;
5604 int val2 ;
5605 int ecode2 = 0 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "min",(char *) "max", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5613 if (obj0) {
5614 ecode1 = SWIG_AsVal_int(obj0, &val1);
5615 if (!SWIG_IsOK(ecode1)) {
5616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5617 }
5618 arg1 = static_cast< int >(val1);
5619 }
5620 if (obj1) {
5621 ecode2 = SWIG_AsVal_int(obj1, &val2);
5622 if (!SWIG_IsOK(ecode2)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5624 }
5625 arg2 = static_cast< int >(val2);
5626 }
5627 {
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5641 PyObject *obj;
5642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5643 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5644 return SWIG_Py_Void();
5645 }
5646
5647 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5648 return SWIG_Python_InitShadowInstance(args);
5649 }
5650
5651 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj = 0;
5653 int arg1 = (int) -1 ;
5654 int arg2 = (int) -1 ;
5655 wxGridCellFloatEditor *result = 0 ;
5656 int val1 ;
5657 int ecode1 = 0 ;
5658 int val2 ;
5659 int ecode2 = 0 ;
5660 PyObject * obj0 = 0 ;
5661 PyObject * obj1 = 0 ;
5662 char * kwnames[] = {
5663 (char *) "width",(char *) "precision", NULL
5664 };
5665
5666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5667 if (obj0) {
5668 ecode1 = SWIG_AsVal_int(obj0, &val1);
5669 if (!SWIG_IsOK(ecode1)) {
5670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5671 }
5672 arg1 = static_cast< int >(val1);
5673 }
5674 if (obj1) {
5675 ecode2 = SWIG_AsVal_int(obj1, &val2);
5676 if (!SWIG_IsOK(ecode2)) {
5677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5678 }
5679 arg2 = static_cast< int >(val2);
5680 }
5681 {
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5695 PyObject *obj;
5696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5697 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5698 return SWIG_Py_Void();
5699 }
5700
5701 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5702 return SWIG_Python_InitShadowInstance(args);
5703 }
5704
5705 SWIGINTERN int OneString_set(PyObject *) {
5706 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5707 return 1;
5708 }
5709
5710
5711 SWIGINTERN PyObject *OneString_get(void) {
5712 PyObject *pyobj = 0;
5713
5714 {
5715 #if wxUSE_UNICODE
5716 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5717 #else
5718 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5719 #endif
5720 }
5721 return pyobj;
5722 }
5723
5724
5725 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5726 PyObject *resultobj = 0;
5727 wxGridCellBoolEditor *result = 0 ;
5728
5729 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5730 {
5731 PyThreadState* __tstate = wxPyBeginAllowThreads();
5732 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5733 wxPyEndAllowThreads(__tstate);
5734 if (PyErr_Occurred()) SWIG_fail;
5735 }
5736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj = 0;
5745 wxString const &arg1_defvalue = wxPyOneString ;
5746 wxString *arg1 = (wxString *) &arg1_defvalue ;
5747 wxString const &arg2_defvalue = wxPyEmptyString ;
5748 wxString *arg2 = (wxString *) &arg2_defvalue ;
5749 bool temp1 = false ;
5750 bool temp2 = false ;
5751 PyObject * obj0 = 0 ;
5752 PyObject * obj1 = 0 ;
5753 char * kwnames[] = {
5754 (char *) "valueTrue",(char *) "valueFalse", NULL
5755 };
5756
5757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5758 if (obj0) {
5759 {
5760 arg1 = wxString_in_helper(obj0);
5761 if (arg1 == NULL) SWIG_fail;
5762 temp1 = true;
5763 }
5764 }
5765 if (obj1) {
5766 {
5767 arg2 = wxString_in_helper(obj1);
5768 if (arg2 == NULL) SWIG_fail;
5769 temp2 = true;
5770 }
5771 }
5772 {
5773 PyThreadState* __tstate = wxPyBeginAllowThreads();
5774 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5775 wxPyEndAllowThreads(__tstate);
5776 if (PyErr_Occurred()) SWIG_fail;
5777 }
5778 resultobj = SWIG_Py_Void();
5779 {
5780 if (temp1)
5781 delete arg1;
5782 }
5783 {
5784 if (temp2)
5785 delete arg2;
5786 }
5787 return resultobj;
5788 fail:
5789 {
5790 if (temp1)
5791 delete arg1;
5792 }
5793 {
5794 if (temp2)
5795 delete arg2;
5796 }
5797 return NULL;
5798 }
5799
5800
5801 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5802 PyObject *resultobj = 0;
5803 wxString *arg1 = 0 ;
5804 bool result;
5805 bool temp1 = false ;
5806 PyObject * obj0 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "value", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5812 {
5813 arg1 = wxString_in_helper(obj0);
5814 if (arg1 == NULL) SWIG_fail;
5815 temp1 = true;
5816 }
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5825 }
5826 {
5827 if (temp1)
5828 delete arg1;
5829 }
5830 return resultobj;
5831 fail:
5832 {
5833 if (temp1)
5834 delete arg1;
5835 }
5836 return NULL;
5837 }
5838
5839
5840 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5841 PyObject *obj;
5842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5843 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5844 return SWIG_Py_Void();
5845 }
5846
5847 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5848 return SWIG_Python_InitShadowInstance(args);
5849 }
5850
5851 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5852 PyObject *resultobj = 0;
5853 int arg1 = (int) 0 ;
5854 wxString *arg2 = (wxString *) NULL ;
5855 bool arg3 = (bool) false ;
5856 wxGridCellChoiceEditor *result = 0 ;
5857 bool val3 ;
5858 int ecode3 = 0 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char * kwnames[] = {
5862 (char *) "choices",(char *) "allowOthers", NULL
5863 };
5864
5865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5866 if (obj0) {
5867 {
5868 arg1 = PyList_Size(obj0);
5869 arg2 = wxString_LIST_helper(obj0);
5870 if (arg2 == NULL) SWIG_fail;
5871 }
5872 }
5873 if (obj1) {
5874 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5875 if (!SWIG_IsOK(ecode3)) {
5876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5877 }
5878 arg3 = static_cast< bool >(val3);
5879 }
5880 {
5881 PyThreadState* __tstate = wxPyBeginAllowThreads();
5882 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5887 {
5888 if (arg2) delete [] arg2;
5889 }
5890 return resultobj;
5891 fail:
5892 {
5893 if (arg2) delete [] arg2;
5894 }
5895 return NULL;
5896 }
5897
5898
5899 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5900 PyObject *obj;
5901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5902 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5903 return SWIG_Py_Void();
5904 }
5905
5906 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5907 return SWIG_Python_InitShadowInstance(args);
5908 }
5909
5910 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj = 0;
5912 wxString const &arg1_defvalue = wxPyEmptyString ;
5913 wxString *arg1 = (wxString *) &arg1_defvalue ;
5914 wxGridCellEnumEditor *result = 0 ;
5915 bool temp1 = false ;
5916 PyObject * obj0 = 0 ;
5917 char * kwnames[] = {
5918 (char *) "choices", NULL
5919 };
5920
5921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5922 if (obj0) {
5923 {
5924 arg1 = wxString_in_helper(obj0);
5925 if (arg1 == NULL) SWIG_fail;
5926 temp1 = true;
5927 }
5928 }
5929 {
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 return resultobj;
5941 fail:
5942 {
5943 if (temp1)
5944 delete arg1;
5945 }
5946 return NULL;
5947 }
5948
5949
5950 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5951 PyObject *obj;
5952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5953 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5954 return SWIG_Py_Void();
5955 }
5956
5957 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5958 return SWIG_Python_InitShadowInstance(args);
5959 }
5960
5961 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 PyObject *resultobj = 0;
5963 wxGridCellAutoWrapStringEditor *result = 0 ;
5964
5965 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5966 {
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5969 wxPyEndAllowThreads(__tstate);
5970 if (PyErr_Occurred()) SWIG_fail;
5971 }
5972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5980 PyObject *obj;
5981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5982 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5983 return SWIG_Py_Void();
5984 }
5985
5986 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5987 return SWIG_Python_InitShadowInstance(args);
5988 }
5989
5990 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5991 PyObject *resultobj = 0;
5992 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5993 PyObject *arg2 = (PyObject *) 0 ;
5994 void *argp1 = 0 ;
5995 int res1 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 char * kwnames[] = {
5999 (char *) "self",(char *) "_self", NULL
6000 };
6001
6002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6004 if (!SWIG_IsOK(res1)) {
6005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6006 }
6007 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6008 arg2 = obj1;
6009 {
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 wxGridCellAttr__setOORInfo(arg1,arg2);
6012 wxPyEndAllowThreads(__tstate);
6013 if (PyErr_Occurred()) SWIG_fail;
6014 }
6015 resultobj = SWIG_Py_Void();
6016 return resultobj;
6017 fail:
6018 return NULL;
6019 }
6020
6021
6022 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6023 PyObject *resultobj = 0;
6024 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6025 wxGridCellAttr *result = 0 ;
6026 void *argp1 = 0 ;
6027 int res1 = 0 ;
6028 PyObject * obj0 = 0 ;
6029 char * kwnames[] = {
6030 (char *) "attrDefault", NULL
6031 };
6032
6033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6034 if (obj0) {
6035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6036 if (!SWIG_IsOK(res1)) {
6037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6038 }
6039 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6040 }
6041 {
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6044 wxPyEndAllowThreads(__tstate);
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 {
6048 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6049 }
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6057 PyObject *resultobj = 0;
6058 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6059 void *argp1 = 0 ;
6060 int res1 = 0 ;
6061 PyObject *swig_obj[1] ;
6062
6063 if (!args) SWIG_fail;
6064 swig_obj[0] = args;
6065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6066 if (!SWIG_IsOK(res1)) {
6067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6068 }
6069 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6070 {
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 delete_wxGridCellAttr(arg1);
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_Py_Void();
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6085 PyObject *resultobj = 0;
6086 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6087 wxGridCellAttr *result = 0 ;
6088 void *argp1 = 0 ;
6089 int res1 = 0 ;
6090 PyObject *swig_obj[1] ;
6091
6092 if (!args) SWIG_fail;
6093 swig_obj[0] = args;
6094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6095 if (!SWIG_IsOK(res1)) {
6096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6097 }
6098 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6099 {
6100 PyThreadState* __tstate = wxPyBeginAllowThreads();
6101 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6102 wxPyEndAllowThreads(__tstate);
6103 if (PyErr_Occurred()) SWIG_fail;
6104 }
6105 {
6106 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6107 }
6108 return resultobj;
6109 fail:
6110 return NULL;
6111 }
6112
6113
6114 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6115 PyObject *resultobj = 0;
6116 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6117 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6118 void *argp1 = 0 ;
6119 int res1 = 0 ;
6120 void *argp2 = 0 ;
6121 int res2 = 0 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char * kwnames[] = {
6125 (char *) "self",(char *) "mergefrom", NULL
6126 };
6127
6128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6130 if (!SWIG_IsOK(res1)) {
6131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6132 }
6133 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6135 if (!SWIG_IsOK(res2)) {
6136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6137 }
6138 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 (arg1)->MergeWith(arg2);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_Py_Void();
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6153 PyObject *resultobj = 0;
6154 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6155 void *argp1 = 0 ;
6156 int res1 = 0 ;
6157 PyObject *swig_obj[1] ;
6158
6159 if (!args) SWIG_fail;
6160 swig_obj[0] = args;
6161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6162 if (!SWIG_IsOK(res1)) {
6163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6164 }
6165 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6166 {
6167 PyThreadState* __tstate = wxPyBeginAllowThreads();
6168 (arg1)->IncRef();
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 resultobj = SWIG_Py_Void();
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 PyObject *resultobj = 0;
6181 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6182 void *argp1 = 0 ;
6183 int res1 = 0 ;
6184 PyObject *swig_obj[1] ;
6185
6186 if (!args) SWIG_fail;
6187 swig_obj[0] = args;
6188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6189 if (!SWIG_IsOK(res1)) {
6190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6191 }
6192 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 (arg1)->DecRef();
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_Py_Void();
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6209 wxColour *arg2 = 0 ;
6210 void *argp1 = 0 ;
6211 int res1 = 0 ;
6212 wxColour temp2 ;
6213 PyObject * obj0 = 0 ;
6214 PyObject * obj1 = 0 ;
6215 char * kwnames[] = {
6216 (char *) "self",(char *) "colText", NULL
6217 };
6218
6219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6221 if (!SWIG_IsOK(res1)) {
6222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6223 }
6224 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6225 {
6226 arg2 = &temp2;
6227 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6228 }
6229 {
6230 PyThreadState* __tstate = wxPyBeginAllowThreads();
6231 (arg1)->SetTextColour((wxColour const &)*arg2);
6232 wxPyEndAllowThreads(__tstate);
6233 if (PyErr_Occurred()) SWIG_fail;
6234 }
6235 resultobj = SWIG_Py_Void();
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6243 PyObject *resultobj = 0;
6244 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6245 wxColour *arg2 = 0 ;
6246 void *argp1 = 0 ;
6247 int res1 = 0 ;
6248 wxColour temp2 ;
6249 PyObject * obj0 = 0 ;
6250 PyObject * obj1 = 0 ;
6251 char * kwnames[] = {
6252 (char *) "self",(char *) "colBack", NULL
6253 };
6254
6255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6257 if (!SWIG_IsOK(res1)) {
6258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6259 }
6260 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6261 {
6262 arg2 = &temp2;
6263 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6264 }
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj = 0;
6280 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6281 wxFont *arg2 = 0 ;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 void *argp2 = 0 ;
6285 int res2 = 0 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char * kwnames[] = {
6289 (char *) "self",(char *) "font", NULL
6290 };
6291
6292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6294 if (!SWIG_IsOK(res1)) {
6295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6296 }
6297 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6299 if (!SWIG_IsOK(res2)) {
6300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6301 }
6302 if (!argp2) {
6303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6304 }
6305 arg2 = reinterpret_cast< wxFont * >(argp2);
6306 {
6307 PyThreadState* __tstate = wxPyBeginAllowThreads();
6308 (arg1)->SetFont((wxFont const &)*arg2);
6309 wxPyEndAllowThreads(__tstate);
6310 if (PyErr_Occurred()) SWIG_fail;
6311 }
6312 resultobj = SWIG_Py_Void();
6313 return resultobj;
6314 fail:
6315 return NULL;
6316 }
6317
6318
6319 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6320 PyObject *resultobj = 0;
6321 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6322 int arg2 ;
6323 int arg3 ;
6324 void *argp1 = 0 ;
6325 int res1 = 0 ;
6326 int val2 ;
6327 int ecode2 = 0 ;
6328 int val3 ;
6329 int ecode3 = 0 ;
6330 PyObject * obj0 = 0 ;
6331 PyObject * obj1 = 0 ;
6332 PyObject * obj2 = 0 ;
6333 char * kwnames[] = {
6334 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6335 };
6336
6337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6339 if (!SWIG_IsOK(res1)) {
6340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6341 }
6342 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6343 ecode2 = SWIG_AsVal_int(obj1, &val2);
6344 if (!SWIG_IsOK(ecode2)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6346 }
6347 arg2 = static_cast< int >(val2);
6348 ecode3 = SWIG_AsVal_int(obj2, &val3);
6349 if (!SWIG_IsOK(ecode3)) {
6350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6351 }
6352 arg3 = static_cast< int >(val3);
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 (arg1)->SetAlignment(arg2,arg3);
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_Py_Void();
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = 0;
6368 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6369 int arg2 ;
6370 int arg3 ;
6371 void *argp1 = 0 ;
6372 int res1 = 0 ;
6373 int val2 ;
6374 int ecode2 = 0 ;
6375 int val3 ;
6376 int ecode3 = 0 ;
6377 PyObject * obj0 = 0 ;
6378 PyObject * obj1 = 0 ;
6379 PyObject * obj2 = 0 ;
6380 char * kwnames[] = {
6381 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6382 };
6383
6384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6386 if (!SWIG_IsOK(res1)) {
6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6388 }
6389 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6390 ecode2 = SWIG_AsVal_int(obj1, &val2);
6391 if (!SWIG_IsOK(ecode2)) {
6392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6393 }
6394 arg2 = static_cast< int >(val2);
6395 ecode3 = SWIG_AsVal_int(obj2, &val3);
6396 if (!SWIG_IsOK(ecode3)) {
6397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6398 }
6399 arg3 = static_cast< int >(val3);
6400 {
6401 PyThreadState* __tstate = wxPyBeginAllowThreads();
6402 (arg1)->SetSize(arg2,arg3);
6403 wxPyEndAllowThreads(__tstate);
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 resultobj = SWIG_Py_Void();
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6416 bool arg2 = (bool) true ;
6417 void *argp1 = 0 ;
6418 int res1 = 0 ;
6419 bool val2 ;
6420 int ecode2 = 0 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "self",(char *) "allow", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6429 if (!SWIG_IsOK(res1)) {
6430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6431 }
6432 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6433 if (obj1) {
6434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6435 if (!SWIG_IsOK(ecode2)) {
6436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6437 }
6438 arg2 = static_cast< bool >(val2);
6439 }
6440 {
6441 PyThreadState* __tstate = wxPyBeginAllowThreads();
6442 (arg1)->SetOverflow(arg2);
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 resultobj = SWIG_Py_Void();
6447 return resultobj;
6448 fail:
6449 return NULL;
6450 }
6451
6452
6453 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6454 PyObject *resultobj = 0;
6455 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6456 bool arg2 = (bool) true ;
6457 void *argp1 = 0 ;
6458 int res1 = 0 ;
6459 bool val2 ;
6460 int ecode2 = 0 ;
6461 PyObject * obj0 = 0 ;
6462 PyObject * obj1 = 0 ;
6463 char * kwnames[] = {
6464 (char *) "self",(char *) "isReadOnly", NULL
6465 };
6466
6467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6469 if (!SWIG_IsOK(res1)) {
6470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6471 }
6472 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6473 if (obj1) {
6474 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6475 if (!SWIG_IsOK(ecode2)) {
6476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6477 }
6478 arg2 = static_cast< bool >(val2);
6479 }
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 (arg1)->SetReadOnly(arg2);
6483 wxPyEndAllowThreads(__tstate);
6484 if (PyErr_Occurred()) SWIG_fail;
6485 }
6486 resultobj = SWIG_Py_Void();
6487 return resultobj;
6488 fail:
6489 return NULL;
6490 }
6491
6492
6493 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6494 PyObject *resultobj = 0;
6495 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6496 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6497 void *argp1 = 0 ;
6498 int res1 = 0 ;
6499 void *argp2 = 0 ;
6500 int res2 = 0 ;
6501 PyObject * obj0 = 0 ;
6502 PyObject * obj1 = 0 ;
6503 char * kwnames[] = {
6504 (char *) "self",(char *) "renderer", NULL
6505 };
6506
6507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6509 if (!SWIG_IsOK(res1)) {
6510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6511 }
6512 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6514 if (!SWIG_IsOK(res2)) {
6515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6516 }
6517 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 (arg1)->SetRenderer(arg2);
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_Py_Void();
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj = 0;
6533 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6534 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 void *argp2 = 0 ;
6538 int res2 = 0 ;
6539 PyObject * obj0 = 0 ;
6540 PyObject * obj1 = 0 ;
6541 char * kwnames[] = {
6542 (char *) "self",(char *) "editor", NULL
6543 };
6544
6545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6547 if (!SWIG_IsOK(res1)) {
6548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6549 }
6550 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6552 if (!SWIG_IsOK(res2)) {
6553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6554 }
6555 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 (arg1)->SetEditor(arg2);
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_Py_Void();
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6572 wxGridCellAttr::wxAttrKind arg2 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 int val2 ;
6576 int ecode2 = 0 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "kind", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6587 }
6588 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6589 ecode2 = SWIG_AsVal_int(obj1, &val2);
6590 if (!SWIG_IsOK(ecode2)) {
6591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6592 }
6593 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 (arg1)->SetKind(arg2);
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_Py_Void();
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6610 bool result;
6611 void *argp1 = 0 ;
6612 int res1 = 0 ;
6613 PyObject *swig_obj[1] ;
6614
6615 if (!args) SWIG_fail;
6616 swig_obj[0] = args;
6617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6618 if (!SWIG_IsOK(res1)) {
6619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6620 }
6621 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 {
6629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6630 }
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638 PyObject *resultobj = 0;
6639 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6640 bool result;
6641 void *argp1 = 0 ;
6642 int res1 = 0 ;
6643 PyObject *swig_obj[1] ;
6644
6645 if (!args) SWIG_fail;
6646 swig_obj[0] = args;
6647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6650 }
6651 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 {
6659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6660 }
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6668 PyObject *resultobj = 0;
6669 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6670 bool result;
6671 void *argp1 = 0 ;
6672 int res1 = 0 ;
6673 PyObject *swig_obj[1] ;
6674
6675 if (!args) SWIG_fail;
6676 swig_obj[0] = args;
6677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6678 if (!SWIG_IsOK(res1)) {
6679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6680 }
6681 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6682 {
6683 PyThreadState* __tstate = wxPyBeginAllowThreads();
6684 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6685 wxPyEndAllowThreads(__tstate);
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 {
6689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6690 }
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6698 PyObject *resultobj = 0;
6699 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6700 bool result;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 PyObject *swig_obj[1] ;
6704
6705 if (!args) SWIG_fail;
6706 swig_obj[0] = args;
6707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6710 }
6711 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 {
6719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6720 }
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6728 PyObject *resultobj = 0;
6729 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6730 bool result;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 PyObject *swig_obj[1] ;
6734
6735 if (!args) SWIG_fail;
6736 swig_obj[0] = args;
6737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6738 if (!SWIG_IsOK(res1)) {
6739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6740 }
6741 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6742 {
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6745 wxPyEndAllowThreads(__tstate);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 {
6749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6750 }
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6760 bool result;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 PyObject *swig_obj[1] ;
6764
6765 if (!args) SWIG_fail;
6766 swig_obj[0] = args;
6767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6770 }
6771 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 PyObject *resultobj = 0;
6789 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6790 bool result;
6791 void *argp1 = 0 ;
6792 int res1 = 0 ;
6793 PyObject *swig_obj[1] ;
6794
6795 if (!args) SWIG_fail;
6796 swig_obj[0] = args;
6797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6798 if (!SWIG_IsOK(res1)) {
6799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6800 }
6801 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 {
6809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6810 }
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6820 bool result;
6821 void *argp1 = 0 ;
6822 int res1 = 0 ;
6823 PyObject *swig_obj[1] ;
6824
6825 if (!args) SWIG_fail;
6826 swig_obj[0] = args;
6827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6828 if (!SWIG_IsOK(res1)) {
6829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6830 }
6831 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 {
6839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6840 }
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6848 PyObject *resultobj = 0;
6849 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6850 wxColour result;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 PyObject *swig_obj[1] ;
6854
6855 if (!args) SWIG_fail;
6856 swig_obj[0] = args;
6857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6858 if (!SWIG_IsOK(res1)) {
6859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6860 }
6861 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6862 {
6863 PyThreadState* __tstate = wxPyBeginAllowThreads();
6864 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6878 wxColour result;
6879 void *argp1 = 0 ;
6880 int res1 = 0 ;
6881 PyObject *swig_obj[1] ;
6882
6883 if (!args) SWIG_fail;
6884 swig_obj[0] = args;
6885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6886 if (!SWIG_IsOK(res1)) {
6887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6888 }
6889 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6890 {
6891 PyThreadState* __tstate = wxPyBeginAllowThreads();
6892 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6906 wxFont result;
6907 void *argp1 = 0 ;
6908 int res1 = 0 ;
6909 PyObject *swig_obj[1] ;
6910
6911 if (!args) SWIG_fail;
6912 swig_obj[0] = args;
6913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6914 if (!SWIG_IsOK(res1)) {
6915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6916 }
6917 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6918 {
6919 PyThreadState* __tstate = wxPyBeginAllowThreads();
6920 result = ((wxGridCellAttr const *)arg1)->GetFont();
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6934 int *arg2 = (int *) 0 ;
6935 int *arg3 = (int *) 0 ;
6936 void *argp1 = 0 ;
6937 int res1 = 0 ;
6938 int temp2 ;
6939 int res2 = SWIG_TMPOBJ ;
6940 int temp3 ;
6941 int res3 = SWIG_TMPOBJ ;
6942 PyObject *swig_obj[1] ;
6943
6944 arg2 = &temp2;
6945 arg3 = &temp3;
6946 if (!args) SWIG_fail;
6947 swig_obj[0] = args;
6948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6951 }
6952 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6953 {
6954 PyThreadState* __tstate = wxPyBeginAllowThreads();
6955 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6956 wxPyEndAllowThreads(__tstate);
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 resultobj = SWIG_Py_Void();
6960 if (SWIG_IsTmpObj(res2)) {
6961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6962 } else {
6963 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6965 }
6966 if (SWIG_IsTmpObj(res3)) {
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6968 } else {
6969 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6971 }
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6979 PyObject *resultobj = 0;
6980 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6981 int *arg2 = (int *) 0 ;
6982 int *arg3 = (int *) 0 ;
6983 void *argp1 = 0 ;
6984 int res1 = 0 ;
6985 int temp2 ;
6986 int res2 = SWIG_TMPOBJ ;
6987 int temp3 ;
6988 int res3 = SWIG_TMPOBJ ;
6989 PyObject *swig_obj[1] ;
6990
6991 arg2 = &temp2;
6992 arg3 = &temp3;
6993 if (!args) SWIG_fail;
6994 swig_obj[0] = args;
6995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6998 }
6999 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 if (SWIG_IsTmpObj(res2)) {
7008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7009 } else {
7010 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7012 }
7013 if (SWIG_IsTmpObj(res3)) {
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7015 } else {
7016 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7018 }
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7026 PyObject *resultobj = 0;
7027 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7028 bool result;
7029 void *argp1 = 0 ;
7030 int res1 = 0 ;
7031 PyObject *swig_obj[1] ;
7032
7033 if (!args) SWIG_fail;
7034 swig_obj[0] = args;
7035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7038 }
7039 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 {
7047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7048 }
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj = 0;
7057 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7058 wxGrid *arg2 = (wxGrid *) 0 ;
7059 int arg3 ;
7060 int arg4 ;
7061 wxGridCellRenderer *result = 0 ;
7062 void *argp1 = 0 ;
7063 int res1 = 0 ;
7064 void *argp2 = 0 ;
7065 int res2 = 0 ;
7066 int val3 ;
7067 int ecode3 = 0 ;
7068 int val4 ;
7069 int ecode4 = 0 ;
7070 PyObject * obj0 = 0 ;
7071 PyObject * obj1 = 0 ;
7072 PyObject * obj2 = 0 ;
7073 PyObject * obj3 = 0 ;
7074 char * kwnames[] = {
7075 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7076 };
7077
7078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7080 if (!SWIG_IsOK(res1)) {
7081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7082 }
7083 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7085 if (!SWIG_IsOK(res2)) {
7086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7087 }
7088 arg2 = reinterpret_cast< wxGrid * >(argp2);
7089 ecode3 = SWIG_AsVal_int(obj2, &val3);
7090 if (!SWIG_IsOK(ecode3)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7092 }
7093 arg3 = static_cast< int >(val3);
7094 ecode4 = SWIG_AsVal_int(obj3, &val4);
7095 if (!SWIG_IsOK(ecode4)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7097 }
7098 arg4 = static_cast< int >(val4);
7099 {
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 {
7106 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7107 }
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7115 PyObject *resultobj = 0;
7116 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7117 wxGrid *arg2 = (wxGrid *) 0 ;
7118 int arg3 ;
7119 int arg4 ;
7120 wxGridCellEditor *result = 0 ;
7121 void *argp1 = 0 ;
7122 int res1 = 0 ;
7123 void *argp2 = 0 ;
7124 int res2 = 0 ;
7125 int val3 ;
7126 int ecode3 = 0 ;
7127 int val4 ;
7128 int ecode4 = 0 ;
7129 PyObject * obj0 = 0 ;
7130 PyObject * obj1 = 0 ;
7131 PyObject * obj2 = 0 ;
7132 PyObject * obj3 = 0 ;
7133 char * kwnames[] = {
7134 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7135 };
7136
7137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7139 if (!SWIG_IsOK(res1)) {
7140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7141 }
7142 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7144 if (!SWIG_IsOK(res2)) {
7145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7146 }
7147 arg2 = reinterpret_cast< wxGrid * >(argp2);
7148 ecode3 = SWIG_AsVal_int(obj2, &val3);
7149 if (!SWIG_IsOK(ecode3)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7151 }
7152 arg3 = static_cast< int >(val3);
7153 ecode4 = SWIG_AsVal_int(obj3, &val4);
7154 if (!SWIG_IsOK(ecode4)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7156 }
7157 arg4 = static_cast< int >(val4);
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 {
7165 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 PyObject *resultobj = 0;
7175 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7176 bool result;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 PyObject *swig_obj[1] ;
7180
7181 if (!args) SWIG_fail;
7182 swig_obj[0] = args;
7183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7186 }
7187 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 {
7195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7196 }
7197 return resultobj;
7198 fail:
7199 return NULL;
7200 }
7201
7202
7203 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7204 PyObject *resultobj = 0;
7205 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7206 wxGridCellAttr::wxAttrKind result;
7207 void *argp1 = 0 ;
7208 int res1 = 0 ;
7209 PyObject *swig_obj[1] ;
7210
7211 if (!args) SWIG_fail;
7212 swig_obj[0] = args;
7213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7216 }
7217 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7221 wxPyEndAllowThreads(__tstate);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 resultobj = SWIG_From_int(static_cast< int >(result));
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7232 PyObject *resultobj = 0;
7233 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7234 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7235 void *argp1 = 0 ;
7236 int res1 = 0 ;
7237 void *argp2 = 0 ;
7238 int res2 = 0 ;
7239 PyObject * obj0 = 0 ;
7240 PyObject * obj1 = 0 ;
7241 char * kwnames[] = {
7242 (char *) "self",(char *) "defAttr", NULL
7243 };
7244
7245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7247 if (!SWIG_IsOK(res1)) {
7248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7249 }
7250 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7252 if (!SWIG_IsOK(res2)) {
7253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7254 }
7255 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 (arg1)->SetDefAttr(arg2);
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 resultobj = SWIG_Py_Void();
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7270 PyObject *obj;
7271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7272 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7273 return SWIG_Py_Void();
7274 }
7275
7276 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7277 return SWIG_Python_InitShadowInstance(args);
7278 }
7279
7280 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7281 PyObject *resultobj = 0;
7282 wxGridCellAttrProvider *result = 0 ;
7283
7284 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 {
7292 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7293 }
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7303 PyObject *arg2 = (PyObject *) 0 ;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "_self", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7316 }
7317 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7318 arg2 = obj1;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_Py_Void();
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7335 int arg2 ;
7336 int arg3 ;
7337 wxGridCellAttr::wxAttrKind arg4 ;
7338 wxGridCellAttr *result = 0 ;
7339 void *argp1 = 0 ;
7340 int res1 = 0 ;
7341 int val2 ;
7342 int ecode2 = 0 ;
7343 int val3 ;
7344 int ecode3 = 0 ;
7345 int val4 ;
7346 int ecode4 = 0 ;
7347 PyObject * obj0 = 0 ;
7348 PyObject * obj1 = 0 ;
7349 PyObject * obj2 = 0 ;
7350 PyObject * obj3 = 0 ;
7351 char * kwnames[] = {
7352 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7353 };
7354
7355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7357 if (!SWIG_IsOK(res1)) {
7358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7359 }
7360 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7361 ecode2 = SWIG_AsVal_int(obj1, &val2);
7362 if (!SWIG_IsOK(ecode2)) {
7363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7364 }
7365 arg2 = static_cast< int >(val2);
7366 ecode3 = SWIG_AsVal_int(obj2, &val3);
7367 if (!SWIG_IsOK(ecode3)) {
7368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7369 }
7370 arg3 = static_cast< int >(val3);
7371 ecode4 = SWIG_AsVal_int(obj3, &val4);
7372 if (!SWIG_IsOK(ecode4)) {
7373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7374 }
7375 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 {
7383 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7384 }
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj = 0;
7393 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7394 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7395 int arg3 ;
7396 int arg4 ;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 void *argp2 = 0 ;
7400 int res2 = 0 ;
7401 int val3 ;
7402 int ecode3 = 0 ;
7403 int val4 ;
7404 int ecode4 = 0 ;
7405 PyObject * obj0 = 0 ;
7406 PyObject * obj1 = 0 ;
7407 PyObject * obj2 = 0 ;
7408 PyObject * obj3 = 0 ;
7409 char * kwnames[] = {
7410 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7411 };
7412
7413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7415 if (!SWIG_IsOK(res1)) {
7416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7417 }
7418 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7420 if (!SWIG_IsOK(res2)) {
7421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7422 }
7423 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7424 ecode3 = SWIG_AsVal_int(obj2, &val3);
7425 if (!SWIG_IsOK(ecode3)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7427 }
7428 arg3 = static_cast< int >(val3);
7429 ecode4 = SWIG_AsVal_int(obj3, &val4);
7430 if (!SWIG_IsOK(ecode4)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7432 }
7433 arg4 = static_cast< int >(val4);
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 (arg1)->SetAttr(arg2,arg3,arg4);
7437 wxPyEndAllowThreads(__tstate);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 resultobj = SWIG_Py_Void();
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = 0;
7449 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7450 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7451 int arg3 ;
7452 void *argp1 = 0 ;
7453 int res1 = 0 ;
7454 void *argp2 = 0 ;
7455 int res2 = 0 ;
7456 int val3 ;
7457 int ecode3 = 0 ;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 PyObject * obj2 = 0 ;
7461 char * kwnames[] = {
7462 (char *) "self",(char *) "attr",(char *) "row", NULL
7463 };
7464
7465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7467 if (!SWIG_IsOK(res1)) {
7468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7469 }
7470 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7472 if (!SWIG_IsOK(res2)) {
7473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7474 }
7475 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7476 ecode3 = SWIG_AsVal_int(obj2, &val3);
7477 if (!SWIG_IsOK(ecode3)) {
7478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7479 }
7480 arg3 = static_cast< int >(val3);
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 (arg1)->SetRowAttr(arg2,arg3);
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 resultobj = SWIG_Py_Void();
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7497 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7498 int arg3 ;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 void *argp2 = 0 ;
7502 int res2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "attr",(char *) "col", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7516 }
7517 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7519 if (!SWIG_IsOK(res2)) {
7520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7521 }
7522 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 (arg1)->SetColAttr(arg2,arg3);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj = 0;
7543 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7544 size_t arg2 ;
7545 int arg3 ;
7546 void *argp1 = 0 ;
7547 int res1 = 0 ;
7548 size_t val2 ;
7549 int ecode2 = 0 ;
7550 int val3 ;
7551 int ecode3 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 PyObject * obj2 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7563 }
7564 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7565 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7566 if (!SWIG_IsOK(ecode2)) {
7567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7568 }
7569 arg2 = static_cast< size_t >(val2);
7570 ecode3 = SWIG_AsVal_int(obj2, &val3);
7571 if (!SWIG_IsOK(ecode3)) {
7572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7573 }
7574 arg3 = static_cast< int >(val3);
7575 {
7576 PyThreadState* __tstate = wxPyBeginAllowThreads();
7577 (arg1)->UpdateAttrRows(arg2,arg3);
7578 wxPyEndAllowThreads(__tstate);
7579 if (PyErr_Occurred()) SWIG_fail;
7580 }
7581 resultobj = SWIG_Py_Void();
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj = 0;
7590 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7591 size_t arg2 ;
7592 int arg3 ;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 size_t val2 ;
7596 int ecode2 = 0 ;
7597 int val3 ;
7598 int ecode3 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 PyObject * obj2 = 0 ;
7602 char * kwnames[] = {
7603 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7604 };
7605
7606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7608 if (!SWIG_IsOK(res1)) {
7609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7610 }
7611 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7612 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7613 if (!SWIG_IsOK(ecode2)) {
7614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7615 }
7616 arg2 = static_cast< size_t >(val2);
7617 ecode3 = SWIG_AsVal_int(obj2, &val3);
7618 if (!SWIG_IsOK(ecode3)) {
7619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7620 }
7621 arg3 = static_cast< int >(val3);
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 (arg1)->UpdateAttrCols(arg2,arg3);
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 resultobj = SWIG_Py_Void();
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7636 PyObject *obj;
7637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7638 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7639 return SWIG_Py_Void();
7640 }
7641
7642 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 return SWIG_Python_InitShadowInstance(args);
7644 }
7645
7646 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 PyObject *resultobj = 0;
7648 wxPyGridCellAttrProvider *result = 0 ;
7649
7650 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7658 return resultobj;
7659 fail:
7660 return NULL;
7661 }
7662
7663
7664 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7665 PyObject *resultobj = 0;
7666 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7667 PyObject *arg2 = (PyObject *) 0 ;
7668 PyObject *arg3 = (PyObject *) 0 ;
7669 void *argp1 = 0 ;
7670 int res1 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 PyObject * obj2 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "self",(char *) "_class", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7682 }
7683 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7684 arg2 = obj1;
7685 arg3 = obj2;
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 (arg1)->_setCallbackInfo(arg2,arg3);
7689 wxPyEndAllowThreads(__tstate);
7690 if (PyErr_Occurred()) SWIG_fail;
7691 }
7692 resultobj = SWIG_Py_Void();
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7700 PyObject *resultobj = 0;
7701 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7702 int arg2 ;
7703 int arg3 ;
7704 wxGridCellAttr::wxAttrKind arg4 ;
7705 wxGridCellAttr *result = 0 ;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 int val2 ;
7709 int ecode2 = 0 ;
7710 int val3 ;
7711 int ecode3 = 0 ;
7712 int val4 ;
7713 int ecode4 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 PyObject * obj2 = 0 ;
7717 PyObject * obj3 = 0 ;
7718 char * kwnames[] = {
7719 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7720 };
7721
7722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7724 if (!SWIG_IsOK(res1)) {
7725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7726 }
7727 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7728 ecode2 = SWIG_AsVal_int(obj1, &val2);
7729 if (!SWIG_IsOK(ecode2)) {
7730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7731 }
7732 arg2 = static_cast< int >(val2);
7733 ecode3 = SWIG_AsVal_int(obj2, &val3);
7734 if (!SWIG_IsOK(ecode3)) {
7735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7736 }
7737 arg3 = static_cast< int >(val3);
7738 ecode4 = SWIG_AsVal_int(obj3, &val4);
7739 if (!SWIG_IsOK(ecode4)) {
7740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7741 }
7742 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 {
7750 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7751 }
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj = 0;
7760 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7761 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7762 int arg3 ;
7763 int arg4 ;
7764 void *argp1 = 0 ;
7765 int res1 = 0 ;
7766 void *argp2 = 0 ;
7767 int res2 = 0 ;
7768 int val3 ;
7769 int ecode3 = 0 ;
7770 int val4 ;
7771 int ecode4 = 0 ;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 PyObject * obj2 = 0 ;
7775 PyObject * obj3 = 0 ;
7776 char * kwnames[] = {
7777 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7778 };
7779
7780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7782 if (!SWIG_IsOK(res1)) {
7783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7784 }
7785 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7787 if (!SWIG_IsOK(res2)) {
7788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7789 }
7790 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7791 ecode3 = SWIG_AsVal_int(obj2, &val3);
7792 if (!SWIG_IsOK(ecode3)) {
7793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7794 }
7795 arg3 = static_cast< int >(val3);
7796 ecode4 = SWIG_AsVal_int(obj3, &val4);
7797 if (!SWIG_IsOK(ecode4)) {
7798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7799 }
7800 arg4 = static_cast< int >(val4);
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 (arg1)->SetAttr(arg2,arg3,arg4);
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 resultobj = SWIG_Py_Void();
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7817 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7818 int arg3 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 void *argp2 = 0 ;
7822 int res2 = 0 ;
7823 int val3 ;
7824 int ecode3 = 0 ;
7825 PyObject * obj0 = 0 ;
7826 PyObject * obj1 = 0 ;
7827 PyObject * obj2 = 0 ;
7828 char * kwnames[] = {
7829 (char *) "self",(char *) "attr",(char *) "row", NULL
7830 };
7831
7832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7836 }
7837 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7839 if (!SWIG_IsOK(res2)) {
7840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7841 }
7842 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7843 ecode3 = SWIG_AsVal_int(obj2, &val3);
7844 if (!SWIG_IsOK(ecode3)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7846 }
7847 arg3 = static_cast< int >(val3);
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 (arg1)->SetRowAttr(arg2,arg3);
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_Py_Void();
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj = 0;
7863 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7864 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7865 int arg3 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 void *argp2 = 0 ;
7869 int res2 = 0 ;
7870 int val3 ;
7871 int ecode3 = 0 ;
7872 PyObject * obj0 = 0 ;
7873 PyObject * obj1 = 0 ;
7874 PyObject * obj2 = 0 ;
7875 char * kwnames[] = {
7876 (char *) "self",(char *) "attr",(char *) "col", NULL
7877 };
7878
7879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7881 if (!SWIG_IsOK(res1)) {
7882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7883 }
7884 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7885 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7886 if (!SWIG_IsOK(res2)) {
7887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7888 }
7889 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7890 ecode3 = SWIG_AsVal_int(obj2, &val3);
7891 if (!SWIG_IsOK(ecode3)) {
7892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7893 }
7894 arg3 = static_cast< int >(val3);
7895 {
7896 PyThreadState* __tstate = wxPyBeginAllowThreads();
7897 (arg1)->SetColAttr(arg2,arg3);
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 resultobj = SWIG_Py_Void();
7902 return resultobj;
7903 fail:
7904 return NULL;
7905 }
7906
7907
7908 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7909 PyObject *obj;
7910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7911 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7912 return SWIG_Py_Void();
7913 }
7914
7915 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 return SWIG_Python_InitShadowInstance(args);
7917 }
7918
7919 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 PyObject *resultobj = 0;
7921 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7922 void *argp1 = 0 ;
7923 int res1 = 0 ;
7924 PyObject *swig_obj[1] ;
7925
7926 if (!args) SWIG_fail;
7927 swig_obj[0] = args;
7928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7929 if (!SWIG_IsOK(res1)) {
7930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7931 }
7932 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 delete arg1;
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 resultobj = SWIG_Py_Void();
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7948 PyObject *resultobj = 0;
7949 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7950 PyObject *arg2 = (PyObject *) 0 ;
7951 void *argp1 = 0 ;
7952 int res1 = 0 ;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 char * kwnames[] = {
7956 (char *) "self",(char *) "_self", NULL
7957 };
7958
7959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7961 if (!SWIG_IsOK(res1)) {
7962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7963 }
7964 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7965 arg2 = obj1;
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 wxGridTableBase__setOORInfo(arg1,arg2);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7980 PyObject *resultobj = 0;
7981 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7982 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 void *argp2 = 0 ;
7986 int res2 = 0 ;
7987 PyObject * obj0 = 0 ;
7988 PyObject * obj1 = 0 ;
7989 char * kwnames[] = {
7990 (char *) "self",(char *) "attrProvider", NULL
7991 };
7992
7993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7995 if (!SWIG_IsOK(res1)) {
7996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7997 }
7998 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8000 if (!SWIG_IsOK(res2)) {
8001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8002 }
8003 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetAttrProvider(arg2);
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *resultobj = 0;
8019 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8020 wxGridCellAttrProvider *result = 0 ;
8021 void *argp1 = 0 ;
8022 int res1 = 0 ;
8023 PyObject *swig_obj[1] ;
8024
8025 if (!args) SWIG_fail;
8026 swig_obj[0] = args;
8027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8028 if (!SWIG_IsOK(res1)) {
8029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8030 }
8031 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 {
8039 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8040 }
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj = 0;
8049 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8050 wxGrid *arg2 = (wxGrid *) 0 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 void *argp2 = 0 ;
8054 int res2 = 0 ;
8055 PyObject * obj0 = 0 ;
8056 PyObject * obj1 = 0 ;
8057 char * kwnames[] = {
8058 (char *) "self",(char *) "grid", NULL
8059 };
8060
8061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8063 if (!SWIG_IsOK(res1)) {
8064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8065 }
8066 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8068 if (!SWIG_IsOK(res2)) {
8069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8070 }
8071 arg2 = reinterpret_cast< wxGrid * >(argp2);
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 (arg1)->SetView(arg2);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_Py_Void();
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8086 PyObject *resultobj = 0;
8087 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8088 wxGrid *result = 0 ;
8089 void *argp1 = 0 ;
8090 int res1 = 0 ;
8091 PyObject *swig_obj[1] ;
8092
8093 if (!args) SWIG_fail;
8094 swig_obj[0] = args;
8095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8096 if (!SWIG_IsOK(res1)) {
8097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8098 }
8099 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 {
8107 resultobj = wxPyMake_wxObject(result, (bool)0);
8108 }
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8116 PyObject *resultobj = 0;
8117 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8118 int result;
8119 void *argp1 = 0 ;
8120 int res1 = 0 ;
8121 PyObject *swig_obj[1] ;
8122
8123 if (!args) SWIG_fail;
8124 swig_obj[0] = args;
8125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8126 if (!SWIG_IsOK(res1)) {
8127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8128 }
8129 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (int)(arg1)->GetNumberRows();
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_From_int(static_cast< int >(result));
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8144 PyObject *resultobj = 0;
8145 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8146 int result;
8147 void *argp1 = 0 ;
8148 int res1 = 0 ;
8149 PyObject *swig_obj[1] ;
8150
8151 if (!args) SWIG_fail;
8152 swig_obj[0] = args;
8153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8154 if (!SWIG_IsOK(res1)) {
8155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8156 }
8157 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (int)(arg1)->GetNumberCols();
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_From_int(static_cast< int >(result));
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj = 0;
8173 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8174 int arg2 ;
8175 int arg3 ;
8176 bool result;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int val2 ;
8180 int ecode2 = 0 ;
8181 int val3 ;
8182 int ecode3 = 0 ;
8183 PyObject * obj0 = 0 ;
8184 PyObject * obj1 = 0 ;
8185 PyObject * obj2 = 0 ;
8186 char * kwnames[] = {
8187 (char *) "self",(char *) "row",(char *) "col", NULL
8188 };
8189
8190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8192 if (!SWIG_IsOK(res1)) {
8193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8194 }
8195 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8196 ecode2 = SWIG_AsVal_int(obj1, &val2);
8197 if (!SWIG_IsOK(ecode2)) {
8198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8199 }
8200 arg2 = static_cast< int >(val2);
8201 ecode3 = SWIG_AsVal_int(obj2, &val3);
8202 if (!SWIG_IsOK(ecode3)) {
8203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8204 }
8205 arg3 = static_cast< int >(val3);
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 {
8213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8214 }
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj = 0;
8223 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8224 int arg2 ;
8225 int arg3 ;
8226 wxString result;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 int val2 ;
8230 int ecode2 = 0 ;
8231 int val3 ;
8232 int ecode3 = 0 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 PyObject * obj2 = 0 ;
8236 char * kwnames[] = {
8237 (char *) "self",(char *) "row",(char *) "col", NULL
8238 };
8239
8240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8242 if (!SWIG_IsOK(res1)) {
8243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8244 }
8245 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8246 ecode2 = SWIG_AsVal_int(obj1, &val2);
8247 if (!SWIG_IsOK(ecode2)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8249 }
8250 arg2 = static_cast< int >(val2);
8251 ecode3 = SWIG_AsVal_int(obj2, &val3);
8252 if (!SWIG_IsOK(ecode3)) {
8253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8254 }
8255 arg3 = static_cast< int >(val3);
8256 {
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 result = (arg1)->GetValue(arg2,arg3);
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 {
8263 #if wxUSE_UNICODE
8264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8265 #else
8266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8267 #endif
8268 }
8269 return resultobj;
8270 fail:
8271 return NULL;
8272 }
8273
8274
8275 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8276 PyObject *resultobj = 0;
8277 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8278 int arg2 ;
8279 int arg3 ;
8280 wxString *arg4 = 0 ;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 int val2 ;
8284 int ecode2 = 0 ;
8285 int val3 ;
8286 int ecode3 = 0 ;
8287 bool temp4 = false ;
8288 PyObject * obj0 = 0 ;
8289 PyObject * obj1 = 0 ;
8290 PyObject * obj2 = 0 ;
8291 PyObject * obj3 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8298 if (!SWIG_IsOK(res1)) {
8299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8300 }
8301 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8302 ecode2 = SWIG_AsVal_int(obj1, &val2);
8303 if (!SWIG_IsOK(ecode2)) {
8304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8305 }
8306 arg2 = static_cast< int >(val2);
8307 ecode3 = SWIG_AsVal_int(obj2, &val3);
8308 if (!SWIG_IsOK(ecode3)) {
8309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8310 }
8311 arg3 = static_cast< int >(val3);
8312 {
8313 arg4 = wxString_in_helper(obj3);
8314 if (arg4 == NULL) SWIG_fail;
8315 temp4 = true;
8316 }
8317 {
8318 PyThreadState* __tstate = wxPyBeginAllowThreads();
8319 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8320 wxPyEndAllowThreads(__tstate);
8321 if (PyErr_Occurred()) SWIG_fail;
8322 }
8323 resultobj = SWIG_Py_Void();
8324 {
8325 if (temp4)
8326 delete arg4;
8327 }
8328 return resultobj;
8329 fail:
8330 {
8331 if (temp4)
8332 delete arg4;
8333 }
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj = 0;
8340 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8341 int arg2 ;
8342 int arg3 ;
8343 wxString result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 int val2 ;
8347 int ecode2 = 0 ;
8348 int val3 ;
8349 int ecode3 = 0 ;
8350 PyObject * obj0 = 0 ;
8351 PyObject * obj1 = 0 ;
8352 PyObject * obj2 = 0 ;
8353 char * kwnames[] = {
8354 (char *) "self",(char *) "row",(char *) "col", NULL
8355 };
8356
8357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8361 }
8362 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8363 ecode2 = SWIG_AsVal_int(obj1, &val2);
8364 if (!SWIG_IsOK(ecode2)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8366 }
8367 arg2 = static_cast< int >(val2);
8368 ecode3 = SWIG_AsVal_int(obj2, &val3);
8369 if (!SWIG_IsOK(ecode3)) {
8370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8371 }
8372 arg3 = static_cast< int >(val3);
8373 {
8374 PyThreadState* __tstate = wxPyBeginAllowThreads();
8375 result = (arg1)->GetTypeName(arg2,arg3);
8376 wxPyEndAllowThreads(__tstate);
8377 if (PyErr_Occurred()) SWIG_fail;
8378 }
8379 {
8380 #if wxUSE_UNICODE
8381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8382 #else
8383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8384 #endif
8385 }
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj = 0;
8394 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8395 int arg2 ;
8396 int arg3 ;
8397 wxString *arg4 = 0 ;
8398 bool result;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 int val2 ;
8402 int ecode2 = 0 ;
8403 int val3 ;
8404 int ecode3 = 0 ;
8405 bool temp4 = false ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 PyObject * obj2 = 0 ;
8409 PyObject * obj3 = 0 ;
8410 char * kwnames[] = {
8411 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8412 };
8413
8414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8416 if (!SWIG_IsOK(res1)) {
8417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8418 }
8419 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8420 ecode2 = SWIG_AsVal_int(obj1, &val2);
8421 if (!SWIG_IsOK(ecode2)) {
8422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8423 }
8424 arg2 = static_cast< int >(val2);
8425 ecode3 = SWIG_AsVal_int(obj2, &val3);
8426 if (!SWIG_IsOK(ecode3)) {
8427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8428 }
8429 arg3 = static_cast< int >(val3);
8430 {
8431 arg4 = wxString_in_helper(obj3);
8432 if (arg4 == NULL) SWIG_fail;
8433 temp4 = true;
8434 }
8435 {
8436 PyThreadState* __tstate = wxPyBeginAllowThreads();
8437 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8438 wxPyEndAllowThreads(__tstate);
8439 if (PyErr_Occurred()) SWIG_fail;
8440 }
8441 {
8442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8443 }
8444 {
8445 if (temp4)
8446 delete arg4;
8447 }
8448 return resultobj;
8449 fail:
8450 {
8451 if (temp4)
8452 delete arg4;
8453 }
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8461 int arg2 ;
8462 int arg3 ;
8463 wxString *arg4 = 0 ;
8464 bool result;
8465 void *argp1 = 0 ;
8466 int res1 = 0 ;
8467 int val2 ;
8468 int ecode2 = 0 ;
8469 int val3 ;
8470 int ecode3 = 0 ;
8471 bool temp4 = false ;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 PyObject * obj2 = 0 ;
8475 PyObject * obj3 = 0 ;
8476 char * kwnames[] = {
8477 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8478 };
8479
8480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8482 if (!SWIG_IsOK(res1)) {
8483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8484 }
8485 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8486 ecode2 = SWIG_AsVal_int(obj1, &val2);
8487 if (!SWIG_IsOK(ecode2)) {
8488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8489 }
8490 arg2 = static_cast< int >(val2);
8491 ecode3 = SWIG_AsVal_int(obj2, &val3);
8492 if (!SWIG_IsOK(ecode3)) {
8493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8494 }
8495 arg3 = static_cast< int >(val3);
8496 {
8497 arg4 = wxString_in_helper(obj3);
8498 if (arg4 == NULL) SWIG_fail;
8499 temp4 = true;
8500 }
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 {
8508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8509 }
8510 {
8511 if (temp4)
8512 delete arg4;
8513 }
8514 return resultobj;
8515 fail:
8516 {
8517 if (temp4)
8518 delete arg4;
8519 }
8520 return NULL;
8521 }
8522
8523
8524 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8525 PyObject *resultobj = 0;
8526 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8527 int arg2 ;
8528 int arg3 ;
8529 long result;
8530 void *argp1 = 0 ;
8531 int res1 = 0 ;
8532 int val2 ;
8533 int ecode2 = 0 ;
8534 int val3 ;
8535 int ecode3 = 0 ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 PyObject * obj2 = 0 ;
8539 char * kwnames[] = {
8540 (char *) "self",(char *) "row",(char *) "col", NULL
8541 };
8542
8543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8545 if (!SWIG_IsOK(res1)) {
8546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8547 }
8548 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8549 ecode2 = SWIG_AsVal_int(obj1, &val2);
8550 if (!SWIG_IsOK(ecode2)) {
8551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8552 }
8553 arg2 = static_cast< int >(val2);
8554 ecode3 = SWIG_AsVal_int(obj2, &val3);
8555 if (!SWIG_IsOK(ecode3)) {
8556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8557 }
8558 arg3 = static_cast< int >(val3);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 resultobj = SWIG_From_long(static_cast< long >(result));
8566 return resultobj;
8567 fail:
8568 return NULL;
8569 }
8570
8571
8572 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8573 PyObject *resultobj = 0;
8574 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8575 int arg2 ;
8576 int arg3 ;
8577 double result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 int val2 ;
8581 int ecode2 = 0 ;
8582 int val3 ;
8583 int ecode3 = 0 ;
8584 PyObject * obj0 = 0 ;
8585 PyObject * obj1 = 0 ;
8586 PyObject * obj2 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "row",(char *) "col", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8595 }
8596 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8597 ecode2 = SWIG_AsVal_int(obj1, &val2);
8598 if (!SWIG_IsOK(ecode2)) {
8599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8600 }
8601 arg2 = static_cast< int >(val2);
8602 ecode3 = SWIG_AsVal_int(obj2, &val3);
8603 if (!SWIG_IsOK(ecode3)) {
8604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8605 }
8606 arg3 = static_cast< int >(val3);
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_From_double(static_cast< double >(result));
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj = 0;
8622 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8623 int arg2 ;
8624 int arg3 ;
8625 bool result;
8626 void *argp1 = 0 ;
8627 int res1 = 0 ;
8628 int val2 ;
8629 int ecode2 = 0 ;
8630 int val3 ;
8631 int ecode3 = 0 ;
8632 PyObject * obj0 = 0 ;
8633 PyObject * obj1 = 0 ;
8634 PyObject * obj2 = 0 ;
8635 char * kwnames[] = {
8636 (char *) "self",(char *) "row",(char *) "col", NULL
8637 };
8638
8639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8641 if (!SWIG_IsOK(res1)) {
8642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8643 }
8644 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8645 ecode2 = SWIG_AsVal_int(obj1, &val2);
8646 if (!SWIG_IsOK(ecode2)) {
8647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8648 }
8649 arg2 = static_cast< int >(val2);
8650 ecode3 = SWIG_AsVal_int(obj2, &val3);
8651 if (!SWIG_IsOK(ecode3)) {
8652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8653 }
8654 arg3 = static_cast< int >(val3);
8655 {
8656 PyThreadState* __tstate = wxPyBeginAllowThreads();
8657 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 {
8662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8663 }
8664 return resultobj;
8665 fail:
8666 return NULL;
8667 }
8668
8669
8670 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8671 PyObject *resultobj = 0;
8672 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8673 int arg2 ;
8674 int arg3 ;
8675 long arg4 ;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 int val2 ;
8679 int ecode2 = 0 ;
8680 int val3 ;
8681 int ecode3 = 0 ;
8682 long val4 ;
8683 int ecode4 = 0 ;
8684 PyObject * obj0 = 0 ;
8685 PyObject * obj1 = 0 ;
8686 PyObject * obj2 = 0 ;
8687 PyObject * obj3 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8696 }
8697 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8698 ecode2 = SWIG_AsVal_int(obj1, &val2);
8699 if (!SWIG_IsOK(ecode2)) {
8700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8701 }
8702 arg2 = static_cast< int >(val2);
8703 ecode3 = SWIG_AsVal_int(obj2, &val3);
8704 if (!SWIG_IsOK(ecode3)) {
8705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8706 }
8707 arg3 = static_cast< int >(val3);
8708 ecode4 = SWIG_AsVal_long(obj3, &val4);
8709 if (!SWIG_IsOK(ecode4)) {
8710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8711 }
8712 arg4 = static_cast< long >(val4);
8713 {
8714 PyThreadState* __tstate = wxPyBeginAllowThreads();
8715 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8716 wxPyEndAllowThreads(__tstate);
8717 if (PyErr_Occurred()) SWIG_fail;
8718 }
8719 resultobj = SWIG_Py_Void();
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj = 0;
8728 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8729 int arg2 ;
8730 int arg3 ;
8731 double arg4 ;
8732 void *argp1 = 0 ;
8733 int res1 = 0 ;
8734 int val2 ;
8735 int ecode2 = 0 ;
8736 int val3 ;
8737 int ecode3 = 0 ;
8738 double val4 ;
8739 int ecode4 = 0 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 PyObject * obj2 = 0 ;
8743 PyObject * obj3 = 0 ;
8744 char * kwnames[] = {
8745 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8746 };
8747
8748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8750 if (!SWIG_IsOK(res1)) {
8751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8752 }
8753 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8754 ecode2 = SWIG_AsVal_int(obj1, &val2);
8755 if (!SWIG_IsOK(ecode2)) {
8756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8757 }
8758 arg2 = static_cast< int >(val2);
8759 ecode3 = SWIG_AsVal_int(obj2, &val3);
8760 if (!SWIG_IsOK(ecode3)) {
8761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8762 }
8763 arg3 = static_cast< int >(val3);
8764 ecode4 = SWIG_AsVal_double(obj3, &val4);
8765 if (!SWIG_IsOK(ecode4)) {
8766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8767 }
8768 arg4 = static_cast< double >(val4);
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_Py_Void();
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = 0;
8784 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8785 int arg2 ;
8786 int arg3 ;
8787 bool arg4 ;
8788 void *argp1 = 0 ;
8789 int res1 = 0 ;
8790 int val2 ;
8791 int ecode2 = 0 ;
8792 int val3 ;
8793 int ecode3 = 0 ;
8794 bool val4 ;
8795 int ecode4 = 0 ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 PyObject * obj2 = 0 ;
8799 PyObject * obj3 = 0 ;
8800 char * kwnames[] = {
8801 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8802 };
8803
8804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8808 }
8809 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8810 ecode2 = SWIG_AsVal_int(obj1, &val2);
8811 if (!SWIG_IsOK(ecode2)) {
8812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8813 }
8814 arg2 = static_cast< int >(val2);
8815 ecode3 = SWIG_AsVal_int(obj2, &val3);
8816 if (!SWIG_IsOK(ecode3)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8818 }
8819 arg3 = static_cast< int >(val3);
8820 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8821 if (!SWIG_IsOK(ecode4)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8823 }
8824 arg4 = static_cast< bool >(val4);
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_Py_Void();
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8839 PyObject *resultobj = 0;
8840 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 PyObject *swig_obj[1] ;
8844
8845 if (!args) SWIG_fail;
8846 swig_obj[0] = args;
8847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8850 }
8851 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 (arg1)->Clear();
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = SWIG_Py_Void();
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj = 0;
8867 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8868 size_t arg2 = (size_t) 0 ;
8869 size_t arg3 = (size_t) 1 ;
8870 bool result;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 size_t val2 ;
8874 int ecode2 = 0 ;
8875 size_t val3 ;
8876 int ecode3 = 0 ;
8877 PyObject * obj0 = 0 ;
8878 PyObject * obj1 = 0 ;
8879 PyObject * obj2 = 0 ;
8880 char * kwnames[] = {
8881 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8882 };
8883
8884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8886 if (!SWIG_IsOK(res1)) {
8887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8888 }
8889 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8890 if (obj1) {
8891 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8892 if (!SWIG_IsOK(ecode2)) {
8893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8894 }
8895 arg2 = static_cast< size_t >(val2);
8896 }
8897 if (obj2) {
8898 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8899 if (!SWIG_IsOK(ecode3)) {
8900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8901 }
8902 arg3 = static_cast< size_t >(val3);
8903 }
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (bool)(arg1)->InsertRows(arg2,arg3);
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 {
8911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8912 }
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8920 PyObject *resultobj = 0;
8921 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8922 size_t arg2 = (size_t) 1 ;
8923 bool result;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 size_t val2 ;
8927 int ecode2 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 PyObject * obj1 = 0 ;
8930 char * kwnames[] = {
8931 (char *) "self",(char *) "numRows", NULL
8932 };
8933
8934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8938 }
8939 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8940 if (obj1) {
8941 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8942 if (!SWIG_IsOK(ecode2)) {
8943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8944 }
8945 arg2 = static_cast< size_t >(val2);
8946 }
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 result = (bool)(arg1)->AppendRows(arg2);
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8955 }
8956 return resultobj;
8957 fail:
8958 return NULL;
8959 }
8960
8961
8962 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj = 0;
8964 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8965 size_t arg2 = (size_t) 0 ;
8966 size_t arg3 = (size_t) 1 ;
8967 bool result;
8968 void *argp1 = 0 ;
8969 int res1 = 0 ;
8970 size_t val2 ;
8971 int ecode2 = 0 ;
8972 size_t val3 ;
8973 int ecode3 = 0 ;
8974 PyObject * obj0 = 0 ;
8975 PyObject * obj1 = 0 ;
8976 PyObject * obj2 = 0 ;
8977 char * kwnames[] = {
8978 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8979 };
8980
8981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8983 if (!SWIG_IsOK(res1)) {
8984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8985 }
8986 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8987 if (obj1) {
8988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8989 if (!SWIG_IsOK(ecode2)) {
8990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8991 }
8992 arg2 = static_cast< size_t >(val2);
8993 }
8994 if (obj2) {
8995 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8996 if (!SWIG_IsOK(ecode3)) {
8997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8998 }
8999 arg3 = static_cast< size_t >(val3);
9000 }
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 {
9008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9009 }
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj = 0;
9018 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9019 size_t arg2 = (size_t) 0 ;
9020 size_t arg3 = (size_t) 1 ;
9021 bool result;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 size_t val2 ;
9025 int ecode2 = 0 ;
9026 size_t val3 ;
9027 int ecode3 = 0 ;
9028 PyObject * obj0 = 0 ;
9029 PyObject * obj1 = 0 ;
9030 PyObject * obj2 = 0 ;
9031 char * kwnames[] = {
9032 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9033 };
9034
9035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9037 if (!SWIG_IsOK(res1)) {
9038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9039 }
9040 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9041 if (obj1) {
9042 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9043 if (!SWIG_IsOK(ecode2)) {
9044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9045 }
9046 arg2 = static_cast< size_t >(val2);
9047 }
9048 if (obj2) {
9049 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9050 if (!SWIG_IsOK(ecode3)) {
9051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9052 }
9053 arg3 = static_cast< size_t >(val3);
9054 }
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 result = (bool)(arg1)->InsertCols(arg2,arg3);
9058 wxPyEndAllowThreads(__tstate);
9059 if (PyErr_Occurred()) SWIG_fail;
9060 }
9061 {
9062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9063 }
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj = 0;
9072 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9073 size_t arg2 = (size_t) 1 ;
9074 bool result;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 size_t val2 ;
9078 int ecode2 = 0 ;
9079 PyObject * obj0 = 0 ;
9080 PyObject * obj1 = 0 ;
9081 char * kwnames[] = {
9082 (char *) "self",(char *) "numCols", NULL
9083 };
9084
9085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9087 if (!SWIG_IsOK(res1)) {
9088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9089 }
9090 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9091 if (obj1) {
9092 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9093 if (!SWIG_IsOK(ecode2)) {
9094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9095 }
9096 arg2 = static_cast< size_t >(val2);
9097 }
9098 {
9099 PyThreadState* __tstate = wxPyBeginAllowThreads();
9100 result = (bool)(arg1)->AppendCols(arg2);
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 {
9105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9106 }
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = 0;
9115 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9116 size_t arg2 = (size_t) 0 ;
9117 size_t arg3 = (size_t) 1 ;
9118 bool result;
9119 void *argp1 = 0 ;
9120 int res1 = 0 ;
9121 size_t val2 ;
9122 int ecode2 = 0 ;
9123 size_t val3 ;
9124 int ecode3 = 0 ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127 PyObject * obj2 = 0 ;
9128 char * kwnames[] = {
9129 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9130 };
9131
9132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9134 if (!SWIG_IsOK(res1)) {
9135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9136 }
9137 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9138 if (obj1) {
9139 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9140 if (!SWIG_IsOK(ecode2)) {
9141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9142 }
9143 arg2 = static_cast< size_t >(val2);
9144 }
9145 if (obj2) {
9146 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9147 if (!SWIG_IsOK(ecode3)) {
9148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9149 }
9150 arg3 = static_cast< size_t >(val3);
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 {
9159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9160 }
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj = 0;
9169 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9170 int arg2 ;
9171 wxString result;
9172 void *argp1 = 0 ;
9173 int res1 = 0 ;
9174 int val2 ;
9175 int ecode2 = 0 ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 char * kwnames[] = {
9179 (char *) "self",(char *) "row", NULL
9180 };
9181
9182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9184 if (!SWIG_IsOK(res1)) {
9185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9186 }
9187 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9188 ecode2 = SWIG_AsVal_int(obj1, &val2);
9189 if (!SWIG_IsOK(ecode2)) {
9190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9191 }
9192 arg2 = static_cast< int >(val2);
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (arg1)->GetRowLabelValue(arg2);
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 {
9200 #if wxUSE_UNICODE
9201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9202 #else
9203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9204 #endif
9205 }
9206 return resultobj;
9207 fail:
9208 return NULL;
9209 }
9210
9211
9212 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9213 PyObject *resultobj = 0;
9214 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9215 int arg2 ;
9216 wxString result;
9217 void *argp1 = 0 ;
9218 int res1 = 0 ;
9219 int val2 ;
9220 int ecode2 = 0 ;
9221 PyObject * obj0 = 0 ;
9222 PyObject * obj1 = 0 ;
9223 char * kwnames[] = {
9224 (char *) "self",(char *) "col", NULL
9225 };
9226
9227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9231 }
9232 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9233 ecode2 = SWIG_AsVal_int(obj1, &val2);
9234 if (!SWIG_IsOK(ecode2)) {
9235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9236 }
9237 arg2 = static_cast< int >(val2);
9238 {
9239 PyThreadState* __tstate = wxPyBeginAllowThreads();
9240 result = (arg1)->GetColLabelValue(arg2);
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 {
9245 #if wxUSE_UNICODE
9246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9247 #else
9248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9249 #endif
9250 }
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9258 PyObject *resultobj = 0;
9259 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9260 int arg2 ;
9261 wxString *arg3 = 0 ;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 int val2 ;
9265 int ecode2 = 0 ;
9266 bool temp3 = false ;
9267 PyObject * obj0 = 0 ;
9268 PyObject * obj1 = 0 ;
9269 PyObject * obj2 = 0 ;
9270 char * kwnames[] = {
9271 (char *) "self",(char *) "row",(char *) "value", NULL
9272 };
9273
9274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9276 if (!SWIG_IsOK(res1)) {
9277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9278 }
9279 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9280 ecode2 = SWIG_AsVal_int(obj1, &val2);
9281 if (!SWIG_IsOK(ecode2)) {
9282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9283 }
9284 arg2 = static_cast< int >(val2);
9285 {
9286 arg3 = wxString_in_helper(obj2);
9287 if (arg3 == NULL) SWIG_fail;
9288 temp3 = true;
9289 }
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_Py_Void();
9297 {
9298 if (temp3)
9299 delete arg3;
9300 }
9301 return resultobj;
9302 fail:
9303 {
9304 if (temp3)
9305 delete arg3;
9306 }
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj = 0;
9313 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9314 int arg2 ;
9315 wxString *arg3 = 0 ;
9316 void *argp1 = 0 ;
9317 int res1 = 0 ;
9318 int val2 ;
9319 int ecode2 = 0 ;
9320 bool temp3 = false ;
9321 PyObject * obj0 = 0 ;
9322 PyObject * obj1 = 0 ;
9323 PyObject * obj2 = 0 ;
9324 char * kwnames[] = {
9325 (char *) "self",(char *) "col",(char *) "value", NULL
9326 };
9327
9328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9332 }
9333 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9334 ecode2 = SWIG_AsVal_int(obj1, &val2);
9335 if (!SWIG_IsOK(ecode2)) {
9336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9337 }
9338 arg2 = static_cast< int >(val2);
9339 {
9340 arg3 = wxString_in_helper(obj2);
9341 if (arg3 == NULL) SWIG_fail;
9342 temp3 = true;
9343 }
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_Py_Void();
9351 {
9352 if (temp3)
9353 delete arg3;
9354 }
9355 return resultobj;
9356 fail:
9357 {
9358 if (temp3)
9359 delete arg3;
9360 }
9361 return NULL;
9362 }
9363
9364
9365 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9366 PyObject *resultobj = 0;
9367 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9368 bool result;
9369 void *argp1 = 0 ;
9370 int res1 = 0 ;
9371 PyObject *swig_obj[1] ;
9372
9373 if (!args) SWIG_fail;
9374 swig_obj[0] = args;
9375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9376 if (!SWIG_IsOK(res1)) {
9377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9378 }
9379 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (bool)(arg1)->CanHaveAttributes();
9383 wxPyEndAllowThreads(__tstate);
9384 if (PyErr_Occurred()) SWIG_fail;
9385 }
9386 {
9387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9388 }
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj = 0;
9397 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9398 int arg2 ;
9399 int arg3 ;
9400 wxGridCellAttr::wxAttrKind arg4 ;
9401 wxGridCellAttr *result = 0 ;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 int val2 ;
9405 int ecode2 = 0 ;
9406 int val3 ;
9407 int ecode3 = 0 ;
9408 int val4 ;
9409 int ecode4 = 0 ;
9410 PyObject * obj0 = 0 ;
9411 PyObject * obj1 = 0 ;
9412 PyObject * obj2 = 0 ;
9413 PyObject * obj3 = 0 ;
9414 char * kwnames[] = {
9415 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9416 };
9417
9418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9422 }
9423 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9424 ecode2 = SWIG_AsVal_int(obj1, &val2);
9425 if (!SWIG_IsOK(ecode2)) {
9426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9427 }
9428 arg2 = static_cast< int >(val2);
9429 ecode3 = SWIG_AsVal_int(obj2, &val3);
9430 if (!SWIG_IsOK(ecode3)) {
9431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9432 }
9433 arg3 = static_cast< int >(val3);
9434 ecode4 = SWIG_AsVal_int(obj3, &val4);
9435 if (!SWIG_IsOK(ecode4)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9437 }
9438 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 {
9446 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9447 }
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
9454 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9455 PyObject *resultobj = 0;
9456 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9457 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9458 int arg3 ;
9459 int arg4 ;
9460 void *argp1 = 0 ;
9461 int res1 = 0 ;
9462 void *argp2 = 0 ;
9463 int res2 = 0 ;
9464 int val3 ;
9465 int ecode3 = 0 ;
9466 int val4 ;
9467 int ecode4 = 0 ;
9468 PyObject * obj0 = 0 ;
9469 PyObject * obj1 = 0 ;
9470 PyObject * obj2 = 0 ;
9471 PyObject * obj3 = 0 ;
9472 char * kwnames[] = {
9473 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9474 };
9475
9476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9478 if (!SWIG_IsOK(res1)) {
9479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9480 }
9481 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9483 if (!SWIG_IsOK(res2)) {
9484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9485 }
9486 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9487 ecode3 = SWIG_AsVal_int(obj2, &val3);
9488 if (!SWIG_IsOK(ecode3)) {
9489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9490 }
9491 arg3 = static_cast< int >(val3);
9492 ecode4 = SWIG_AsVal_int(obj3, &val4);
9493 if (!SWIG_IsOK(ecode4)) {
9494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9495 }
9496 arg4 = static_cast< int >(val4);
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 (arg1)->SetAttr(arg2,arg3,arg4);
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_Py_Void();
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj = 0;
9512 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9513 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9514 int arg3 ;
9515 void *argp1 = 0 ;
9516 int res1 = 0 ;
9517 void *argp2 = 0 ;
9518 int res2 = 0 ;
9519 int val3 ;
9520 int ecode3 = 0 ;
9521 PyObject * obj0 = 0 ;
9522 PyObject * obj1 = 0 ;
9523 PyObject * obj2 = 0 ;
9524 char * kwnames[] = {
9525 (char *) "self",(char *) "attr",(char *) "row", NULL
9526 };
9527
9528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9530 if (!SWIG_IsOK(res1)) {
9531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9532 }
9533 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9534 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9535 if (!SWIG_IsOK(res2)) {
9536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9537 }
9538 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9539 ecode3 = SWIG_AsVal_int(obj2, &val3);
9540 if (!SWIG_IsOK(ecode3)) {
9541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9542 }
9543 arg3 = static_cast< int >(val3);
9544 {
9545 PyThreadState* __tstate = wxPyBeginAllowThreads();
9546 (arg1)->SetRowAttr(arg2,arg3);
9547 wxPyEndAllowThreads(__tstate);
9548 if (PyErr_Occurred()) SWIG_fail;
9549 }
9550 resultobj = SWIG_Py_Void();
9551 return resultobj;
9552 fail:
9553 return NULL;
9554 }
9555
9556
9557 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj = 0;
9559 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9560 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9561 int arg3 ;
9562 void *argp1 = 0 ;
9563 int res1 = 0 ;
9564 void *argp2 = 0 ;
9565 int res2 = 0 ;
9566 int val3 ;
9567 int ecode3 = 0 ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 PyObject * obj2 = 0 ;
9571 char * kwnames[] = {
9572 (char *) "self",(char *) "attr",(char *) "col", NULL
9573 };
9574
9575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9577 if (!SWIG_IsOK(res1)) {
9578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9579 }
9580 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9582 if (!SWIG_IsOK(res2)) {
9583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9584 }
9585 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9586 ecode3 = SWIG_AsVal_int(obj2, &val3);
9587 if (!SWIG_IsOK(ecode3)) {
9588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9589 }
9590 arg3 = static_cast< int >(val3);
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 (arg1)->SetColAttr(arg2,arg3);
9594 wxPyEndAllowThreads(__tstate);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 resultobj = SWIG_Py_Void();
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9605 PyObject *obj;
9606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9607 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9608 return SWIG_Py_Void();
9609 }
9610
9611 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxPyGridTableBase *result = 0 ;
9614
9615 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = 0;
9631 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9632 PyObject *arg2 = (PyObject *) 0 ;
9633 PyObject *arg3 = (PyObject *) 0 ;
9634 void *argp1 = 0 ;
9635 int res1 = 0 ;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 PyObject * obj2 = 0 ;
9639 char * kwnames[] = {
9640 (char *) "self",(char *) "self",(char *) "_class", NULL
9641 };
9642
9643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9647 }
9648 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9649 arg2 = obj1;
9650 arg3 = obj2;
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 (arg1)->_setCallbackInfo(arg2,arg3);
9654 wxPyEndAllowThreads(__tstate);
9655 if (PyErr_Occurred()) SWIG_fail;
9656 }
9657 resultobj = SWIG_Py_Void();
9658 return resultobj;
9659 fail:
9660 return NULL;
9661 }
9662
9663
9664 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9665 PyObject *resultobj = 0;
9666 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9667 void *argp1 = 0 ;
9668 int res1 = 0 ;
9669 PyObject *swig_obj[1] ;
9670
9671 if (!args) SWIG_fail;
9672 swig_obj[0] = args;
9673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9674 if (!SWIG_IsOK(res1)) {
9675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9676 }
9677 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9678 {
9679 PyThreadState* __tstate = wxPyBeginAllowThreads();
9680 wxPyGridTableBase_Destroy(arg1);
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 resultobj = SWIG_Py_Void();
9685 return resultobj;
9686 fail:
9687 return NULL;
9688 }
9689
9690
9691 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9692 PyObject *obj;
9693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9694 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9695 return SWIG_Py_Void();
9696 }
9697
9698 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9699 return SWIG_Python_InitShadowInstance(args);
9700 }
9701
9702 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj = 0;
9704 int arg1 = (int) 0 ;
9705 int arg2 = (int) 0 ;
9706 wxGridStringTable *result = 0 ;
9707 int val1 ;
9708 int ecode1 = 0 ;
9709 int val2 ;
9710 int ecode2 = 0 ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 char * kwnames[] = {
9714 (char *) "numRows",(char *) "numCols", NULL
9715 };
9716
9717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9718 if (obj0) {
9719 ecode1 = SWIG_AsVal_int(obj0, &val1);
9720 if (!SWIG_IsOK(ecode1)) {
9721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9722 }
9723 arg1 = static_cast< int >(val1);
9724 }
9725 if (obj1) {
9726 ecode2 = SWIG_AsVal_int(obj1, &val2);
9727 if (!SWIG_IsOK(ecode2)) {
9728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9729 }
9730 arg2 = static_cast< int >(val2);
9731 }
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *obj;
9747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9748 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9749 return SWIG_Py_Void();
9750 }
9751
9752 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9753 return SWIG_Python_InitShadowInstance(args);
9754 }
9755
9756 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj = 0;
9758 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9759 int arg2 ;
9760 int arg3 = (int) -1 ;
9761 int arg4 = (int) -1 ;
9762 wxGridTableMessage *result = 0 ;
9763 void *argp1 = 0 ;
9764 int res1 = 0 ;
9765 int val2 ;
9766 int ecode2 = 0 ;
9767 int val3 ;
9768 int ecode3 = 0 ;
9769 int val4 ;
9770 int ecode4 = 0 ;
9771 PyObject * obj0 = 0 ;
9772 PyObject * obj1 = 0 ;
9773 PyObject * obj2 = 0 ;
9774 PyObject * obj3 = 0 ;
9775 char * kwnames[] = {
9776 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9777 };
9778
9779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9781 if (!SWIG_IsOK(res1)) {
9782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9783 }
9784 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9785 ecode2 = SWIG_AsVal_int(obj1, &val2);
9786 if (!SWIG_IsOK(ecode2)) {
9787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9788 }
9789 arg2 = static_cast< int >(val2);
9790 if (obj2) {
9791 ecode3 = SWIG_AsVal_int(obj2, &val3);
9792 if (!SWIG_IsOK(ecode3)) {
9793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9794 }
9795 arg3 = static_cast< int >(val3);
9796 }
9797 if (obj3) {
9798 ecode4 = SWIG_AsVal_int(obj3, &val4);
9799 if (!SWIG_IsOK(ecode4)) {
9800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9801 }
9802 arg4 = static_cast< int >(val4);
9803 }
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *resultobj = 0;
9819 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 PyObject *swig_obj[1] ;
9823
9824 if (!args) SWIG_fail;
9825 swig_obj[0] = args;
9826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9829 }
9830 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 delete arg1;
9834
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 resultobj = SWIG_Py_Void();
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9846 PyObject *resultobj = 0;
9847 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9848 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9849 void *argp1 = 0 ;
9850 int res1 = 0 ;
9851 void *argp2 = 0 ;
9852 int res2 = 0 ;
9853 PyObject * obj0 = 0 ;
9854 PyObject * obj1 = 0 ;
9855 char * kwnames[] = {
9856 (char *) "self",(char *) "table", NULL
9857 };
9858
9859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9861 if (!SWIG_IsOK(res1)) {
9862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9863 }
9864 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9866 if (!SWIG_IsOK(res2)) {
9867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9868 }
9869 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 (arg1)->SetTableObject(arg2);
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 resultobj = SWIG_Py_Void();
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9884 PyObject *resultobj = 0;
9885 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9886 wxGridTableBase *result = 0 ;
9887 void *argp1 = 0 ;
9888 int res1 = 0 ;
9889 PyObject *swig_obj[1] ;
9890
9891 if (!args) SWIG_fail;
9892 swig_obj[0] = args;
9893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9894 if (!SWIG_IsOK(res1)) {
9895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9896 }
9897 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9898 {
9899 PyThreadState* __tstate = wxPyBeginAllowThreads();
9900 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9906 }
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj = 0;
9915 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9916 int arg2 ;
9917 void *argp1 = 0 ;
9918 int res1 = 0 ;
9919 int val2 ;
9920 int ecode2 = 0 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char * kwnames[] = {
9924 (char *) "self",(char *) "id", NULL
9925 };
9926
9927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9931 }
9932 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9933 ecode2 = SWIG_AsVal_int(obj1, &val2);
9934 if (!SWIG_IsOK(ecode2)) {
9935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9936 }
9937 arg2 = static_cast< int >(val2);
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 (arg1)->SetId(arg2);
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 resultobj = SWIG_Py_Void();
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9952 PyObject *resultobj = 0;
9953 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9954 int result;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 PyObject *swig_obj[1] ;
9958
9959 if (!args) SWIG_fail;
9960 swig_obj[0] = args;
9961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9962 if (!SWIG_IsOK(res1)) {
9963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9964 }
9965 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 result = (int)(arg1)->GetId();
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 resultobj = SWIG_From_int(static_cast< int >(result));
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj = 0;
9981 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9982 int arg2 ;
9983 void *argp1 = 0 ;
9984 int res1 = 0 ;
9985 int val2 ;
9986 int ecode2 = 0 ;
9987 PyObject * obj0 = 0 ;
9988 PyObject * obj1 = 0 ;
9989 char * kwnames[] = {
9990 (char *) "self",(char *) "comInt1", NULL
9991 };
9992
9993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9995 if (!SWIG_IsOK(res1)) {
9996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9997 }
9998 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9999 ecode2 = SWIG_AsVal_int(obj1, &val2);
10000 if (!SWIG_IsOK(ecode2)) {
10001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10002 }
10003 arg2 = static_cast< int >(val2);
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 (arg1)->SetCommandInt(arg2);
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 resultobj = SWIG_Py_Void();
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10018 PyObject *resultobj = 0;
10019 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10020 int result;
10021 void *argp1 = 0 ;
10022 int res1 = 0 ;
10023 PyObject *swig_obj[1] ;
10024
10025 if (!args) SWIG_fail;
10026 swig_obj[0] = args;
10027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10028 if (!SWIG_IsOK(res1)) {
10029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10030 }
10031 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 result = (int)(arg1)->GetCommandInt();
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_From_int(static_cast< int >(result));
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10048 int arg2 ;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 int val2 ;
10052 int ecode2 = 0 ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "comInt2", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10063 }
10064 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10065 ecode2 = SWIG_AsVal_int(obj1, &val2);
10066 if (!SWIG_IsOK(ecode2)) {
10067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10068 }
10069 arg2 = static_cast< int >(val2);
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 (arg1)->SetCommandInt2(arg2);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 resultobj = SWIG_Py_Void();
10077 return resultobj;
10078 fail:
10079 return NULL;
10080 }
10081
10082
10083 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10084 PyObject *resultobj = 0;
10085 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10086 int result;
10087 void *argp1 = 0 ;
10088 int res1 = 0 ;
10089 PyObject *swig_obj[1] ;
10090
10091 if (!args) SWIG_fail;
10092 swig_obj[0] = args;
10093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10094 if (!SWIG_IsOK(res1)) {
10095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10096 }
10097 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10098 {
10099 PyThreadState* __tstate = wxPyBeginAllowThreads();
10100 result = (int)(arg1)->GetCommandInt2();
10101 wxPyEndAllowThreads(__tstate);
10102 if (PyErr_Occurred()) SWIG_fail;
10103 }
10104 resultobj = SWIG_From_int(static_cast< int >(result));
10105 return resultobj;
10106 fail:
10107 return NULL;
10108 }
10109
10110
10111 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10112 PyObject *obj;
10113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10114 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10115 return SWIG_Py_Void();
10116 }
10117
10118 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10119 return SWIG_Python_InitShadowInstance(args);
10120 }
10121
10122 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10123 PyObject *resultobj = 0;
10124 int arg1 = (int) -1 ;
10125 int arg2 = (int) -1 ;
10126 wxGridCellCoords *result = 0 ;
10127 int val1 ;
10128 int ecode1 = 0 ;
10129 int val2 ;
10130 int ecode2 = 0 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "r",(char *) "c", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10138 if (obj0) {
10139 ecode1 = SWIG_AsVal_int(obj0, &val1);
10140 if (!SWIG_IsOK(ecode1)) {
10141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10142 }
10143 arg1 = static_cast< int >(val1);
10144 }
10145 if (obj1) {
10146 ecode2 = SWIG_AsVal_int(obj1, &val2);
10147 if (!SWIG_IsOK(ecode2)) {
10148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10149 }
10150 arg2 = static_cast< int >(val2);
10151 }
10152 {
10153 PyThreadState* __tstate = wxPyBeginAllowThreads();
10154 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10155 wxPyEndAllowThreads(__tstate);
10156 if (PyErr_Occurred()) SWIG_fail;
10157 }
10158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 PyObject *resultobj = 0;
10167 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10168 void *argp1 = 0 ;
10169 int res1 = 0 ;
10170 PyObject *swig_obj[1] ;
10171
10172 if (!args) SWIG_fail;
10173 swig_obj[0] = args;
10174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10177 }
10178 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10179 {
10180 PyThreadState* __tstate = wxPyBeginAllowThreads();
10181 delete arg1;
10182
10183 wxPyEndAllowThreads(__tstate);
10184 if (PyErr_Occurred()) SWIG_fail;
10185 }
10186 resultobj = SWIG_Py_Void();
10187 return resultobj;
10188 fail:
10189 return NULL;
10190 }
10191
10192
10193 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10194 PyObject *resultobj = 0;
10195 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10196 int result;
10197 void *argp1 = 0 ;
10198 int res1 = 0 ;
10199 PyObject *swig_obj[1] ;
10200
10201 if (!args) SWIG_fail;
10202 swig_obj[0] = args;
10203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10204 if (!SWIG_IsOK(res1)) {
10205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10206 }
10207 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10208 {
10209 PyThreadState* __tstate = wxPyBeginAllowThreads();
10210 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10211 wxPyEndAllowThreads(__tstate);
10212 if (PyErr_Occurred()) SWIG_fail;
10213 }
10214 resultobj = SWIG_From_int(static_cast< int >(result));
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj = 0;
10223 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10224 int arg2 ;
10225 void *argp1 = 0 ;
10226 int res1 = 0 ;
10227 int val2 ;
10228 int ecode2 = 0 ;
10229 PyObject * obj0 = 0 ;
10230 PyObject * obj1 = 0 ;
10231 char * kwnames[] = {
10232 (char *) "self",(char *) "n", NULL
10233 };
10234
10235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10237 if (!SWIG_IsOK(res1)) {
10238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10239 }
10240 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10241 ecode2 = SWIG_AsVal_int(obj1, &val2);
10242 if (!SWIG_IsOK(ecode2)) {
10243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10244 }
10245 arg2 = static_cast< int >(val2);
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 (arg1)->SetRow(arg2);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 resultobj = SWIG_Py_Void();
10253 return resultobj;
10254 fail:
10255 return NULL;
10256 }
10257
10258
10259 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10260 PyObject *resultobj = 0;
10261 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10262 int result;
10263 void *argp1 = 0 ;
10264 int res1 = 0 ;
10265 PyObject *swig_obj[1] ;
10266
10267 if (!args) SWIG_fail;
10268 swig_obj[0] = args;
10269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10270 if (!SWIG_IsOK(res1)) {
10271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10272 }
10273 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 resultobj = SWIG_From_int(static_cast< int >(result));
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = 0;
10289 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10290 int arg2 ;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 int val2 ;
10294 int ecode2 = 0 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char * kwnames[] = {
10298 (char *) "self",(char *) "n", NULL
10299 };
10300
10301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10305 }
10306 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10307 ecode2 = SWIG_AsVal_int(obj1, &val2);
10308 if (!SWIG_IsOK(ecode2)) {
10309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10310 }
10311 arg2 = static_cast< int >(val2);
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 (arg1)->SetCol(arg2);
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_Py_Void();
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = 0;
10327 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10328 int arg2 ;
10329 int arg3 ;
10330 void *argp1 = 0 ;
10331 int res1 = 0 ;
10332 int val2 ;
10333 int ecode2 = 0 ;
10334 int val3 ;
10335 int ecode3 = 0 ;
10336 PyObject * obj0 = 0 ;
10337 PyObject * obj1 = 0 ;
10338 PyObject * obj2 = 0 ;
10339 char * kwnames[] = {
10340 (char *) "self",(char *) "row",(char *) "col", NULL
10341 };
10342
10343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10345 if (!SWIG_IsOK(res1)) {
10346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10347 }
10348 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10349 ecode2 = SWIG_AsVal_int(obj1, &val2);
10350 if (!SWIG_IsOK(ecode2)) {
10351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10352 }
10353 arg2 = static_cast< int >(val2);
10354 ecode3 = SWIG_AsVal_int(obj2, &val3);
10355 if (!SWIG_IsOK(ecode3)) {
10356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10357 }
10358 arg3 = static_cast< int >(val3);
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 (arg1)->Set(arg2,arg3);
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 resultobj = SWIG_Py_Void();
10366 return resultobj;
10367 fail:
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj = 0;
10374 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10375 PyObject *arg2 = (PyObject *) 0 ;
10376 bool result;
10377 void *argp1 = 0 ;
10378 int res1 = 0 ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 char * kwnames[] = {
10382 (char *) "self",(char *) "other", NULL
10383 };
10384
10385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10387 if (!SWIG_IsOK(res1)) {
10388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10389 }
10390 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10391 arg2 = obj1;
10392 {
10393 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 {
10397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10398 }
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10408 PyObject *arg2 = (PyObject *) 0 ;
10409 bool result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414 char * kwnames[] = {
10415 (char *) "self",(char *) "other", NULL
10416 };
10417
10418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10422 }
10423 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10424 arg2 = obj1;
10425 {
10426 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10431 }
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10439 PyObject *resultobj = 0;
10440 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10441 PyObject *result = 0 ;
10442 void *argp1 = 0 ;
10443 int res1 = 0 ;
10444 PyObject *swig_obj[1] ;
10445
10446 if (!args) SWIG_fail;
10447 swig_obj[0] = args;
10448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10451 }
10452 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 result = (PyObject *)wxGridCellCoords_Get(arg1);
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 resultobj = result;
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10467 PyObject *obj;
10468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10469 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10470 return SWIG_Py_Void();
10471 }
10472
10473 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 return SWIG_Python_InitShadowInstance(args);
10475 }
10476
10477 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj = 0;
10479 wxWindow *arg1 = (wxWindow *) 0 ;
10480 int arg2 = (int) -1 ;
10481 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10482 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10483 wxSize const &arg4_defvalue = wxDefaultSize ;
10484 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10485 long arg5 = (long) wxWANTS_CHARS ;
10486 wxString const &arg6_defvalue = wxPyGridNameStr ;
10487 wxString *arg6 = (wxString *) &arg6_defvalue ;
10488 wxGrid *result = 0 ;
10489 void *argp1 = 0 ;
10490 int res1 = 0 ;
10491 int val2 ;
10492 int ecode2 = 0 ;
10493 wxPoint temp3 ;
10494 wxSize temp4 ;
10495 long val5 ;
10496 int ecode5 = 0 ;
10497 bool temp6 = false ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 PyObject * obj2 = 0 ;
10501 PyObject * obj3 = 0 ;
10502 PyObject * obj4 = 0 ;
10503 PyObject * obj5 = 0 ;
10504 char * kwnames[] = {
10505 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10506 };
10507
10508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10512 }
10513 arg1 = reinterpret_cast< wxWindow * >(argp1);
10514 if (obj1) {
10515 ecode2 = SWIG_AsVal_int(obj1, &val2);
10516 if (!SWIG_IsOK(ecode2)) {
10517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10518 }
10519 arg2 = static_cast< int >(val2);
10520 }
10521 if (obj2) {
10522 {
10523 arg3 = &temp3;
10524 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10525 }
10526 }
10527 if (obj3) {
10528 {
10529 arg4 = &temp4;
10530 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10531 }
10532 }
10533 if (obj4) {
10534 ecode5 = SWIG_AsVal_long(obj4, &val5);
10535 if (!SWIG_IsOK(ecode5)) {
10536 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10537 }
10538 arg5 = static_cast< long >(val5);
10539 }
10540 if (obj5) {
10541 {
10542 arg6 = wxString_in_helper(obj5);
10543 if (arg6 == NULL) SWIG_fail;
10544 temp6 = true;
10545 }
10546 }
10547 {
10548 if (!wxPyCheckForApp()) SWIG_fail;
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10555 {
10556 if (temp6)
10557 delete arg6;
10558 }
10559 return resultobj;
10560 fail:
10561 {
10562 if (temp6)
10563 delete arg6;
10564 }
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10570 PyObject *resultobj = 0;
10571 wxGrid *result = 0 ;
10572
10573 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10574 {
10575 if (!wxPyCheckForApp()) SWIG_fail;
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 result = (wxGrid *)new wxGrid();
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10582 return resultobj;
10583 fail:
10584 return NULL;
10585 }
10586
10587
10588 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10589 PyObject *resultobj = 0;
10590 wxGrid *arg1 = (wxGrid *) 0 ;
10591 wxWindow *arg2 = (wxWindow *) 0 ;
10592 int arg3 = (int) -1 ;
10593 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10594 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10595 wxSize const &arg5_defvalue = wxDefaultSize ;
10596 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10597 long arg6 = (long) wxWANTS_CHARS ;
10598 wxString const &arg7_defvalue = wxPyGridNameStr ;
10599 wxString *arg7 = (wxString *) &arg7_defvalue ;
10600 bool result;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 void *argp2 = 0 ;
10604 int res2 = 0 ;
10605 int val3 ;
10606 int ecode3 = 0 ;
10607 wxPoint temp4 ;
10608 wxSize temp5 ;
10609 long val6 ;
10610 int ecode6 = 0 ;
10611 bool temp7 = false ;
10612 PyObject * obj0 = 0 ;
10613 PyObject * obj1 = 0 ;
10614 PyObject * obj2 = 0 ;
10615 PyObject * obj3 = 0 ;
10616 PyObject * obj4 = 0 ;
10617 PyObject * obj5 = 0 ;
10618 PyObject * obj6 = 0 ;
10619 char * kwnames[] = {
10620 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10621 };
10622
10623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10625 if (!SWIG_IsOK(res1)) {
10626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10627 }
10628 arg1 = reinterpret_cast< wxGrid * >(argp1);
10629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10630 if (!SWIG_IsOK(res2)) {
10631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10632 }
10633 arg2 = reinterpret_cast< wxWindow * >(argp2);
10634 if (obj2) {
10635 ecode3 = SWIG_AsVal_int(obj2, &val3);
10636 if (!SWIG_IsOK(ecode3)) {
10637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10638 }
10639 arg3 = static_cast< int >(val3);
10640 }
10641 if (obj3) {
10642 {
10643 arg4 = &temp4;
10644 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10645 }
10646 }
10647 if (obj4) {
10648 {
10649 arg5 = &temp5;
10650 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10651 }
10652 }
10653 if (obj5) {
10654 ecode6 = SWIG_AsVal_long(obj5, &val6);
10655 if (!SWIG_IsOK(ecode6)) {
10656 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10657 }
10658 arg6 = static_cast< long >(val6);
10659 }
10660 if (obj6) {
10661 {
10662 arg7 = wxString_in_helper(obj6);
10663 if (arg7 == NULL) SWIG_fail;
10664 temp7 = true;
10665 }
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10675 }
10676 {
10677 if (temp7)
10678 delete arg7;
10679 }
10680 return resultobj;
10681 fail:
10682 {
10683 if (temp7)
10684 delete arg7;
10685 }
10686 return NULL;
10687 }
10688
10689
10690 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj = 0;
10692 wxGrid *arg1 = (wxGrid *) 0 ;
10693 int arg2 ;
10694 int arg3 ;
10695 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10696 bool result;
10697 void *argp1 = 0 ;
10698 int res1 = 0 ;
10699 int val2 ;
10700 int ecode2 = 0 ;
10701 int val3 ;
10702 int ecode3 = 0 ;
10703 int val4 ;
10704 int ecode4 = 0 ;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 PyObject * obj2 = 0 ;
10708 PyObject * obj3 = 0 ;
10709 char * kwnames[] = {
10710 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10711 };
10712
10713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10715 if (!SWIG_IsOK(res1)) {
10716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10717 }
10718 arg1 = reinterpret_cast< wxGrid * >(argp1);
10719 ecode2 = SWIG_AsVal_int(obj1, &val2);
10720 if (!SWIG_IsOK(ecode2)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10722 }
10723 arg2 = static_cast< int >(val2);
10724 ecode3 = SWIG_AsVal_int(obj2, &val3);
10725 if (!SWIG_IsOK(ecode3)) {
10726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10727 }
10728 arg3 = static_cast< int >(val3);
10729 if (obj3) {
10730 ecode4 = SWIG_AsVal_int(obj3, &val4);
10731 if (!SWIG_IsOK(ecode4)) {
10732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10733 }
10734 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10735 }
10736 {
10737 PyThreadState* __tstate = wxPyBeginAllowThreads();
10738 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 {
10743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10744 }
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj = 0;
10753 wxGrid *arg1 = (wxGrid *) 0 ;
10754 WXGRIDSELECTIONMODES arg2 ;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 int val2 ;
10758 int ecode2 = 0 ;
10759 PyObject * obj0 = 0 ;
10760 PyObject * obj1 = 0 ;
10761 char * kwnames[] = {
10762 (char *) "self",(char *) "selmode", NULL
10763 };
10764
10765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10767 if (!SWIG_IsOK(res1)) {
10768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10769 }
10770 arg1 = reinterpret_cast< wxGrid * >(argp1);
10771 ecode2 = SWIG_AsVal_int(obj1, &val2);
10772 if (!SWIG_IsOK(ecode2)) {
10773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10774 }
10775 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10776 {
10777 PyThreadState* __tstate = wxPyBeginAllowThreads();
10778 (arg1)->SetSelectionMode(arg2);
10779 wxPyEndAllowThreads(__tstate);
10780 if (PyErr_Occurred()) SWIG_fail;
10781 }
10782 resultobj = SWIG_Py_Void();
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10790 PyObject *resultobj = 0;
10791 wxGrid *arg1 = (wxGrid *) 0 ;
10792 WXGRIDSELECTIONMODES result;
10793 void *argp1 = 0 ;
10794 int res1 = 0 ;
10795 PyObject *swig_obj[1] ;
10796
10797 if (!args) SWIG_fail;
10798 swig_obj[0] = args;
10799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10802 }
10803 arg1 = reinterpret_cast< wxGrid * >(argp1);
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 resultobj = SWIG_From_int(static_cast< int >(result));
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10818 PyObject *resultobj = 0;
10819 wxGrid *arg1 = (wxGrid *) 0 ;
10820 int result;
10821 void *argp1 = 0 ;
10822 int res1 = 0 ;
10823 PyObject *swig_obj[1] ;
10824
10825 if (!args) SWIG_fail;
10826 swig_obj[0] = args;
10827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10828 if (!SWIG_IsOK(res1)) {
10829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10830 }
10831 arg1 = reinterpret_cast< wxGrid * >(argp1);
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = (int)(arg1)->GetNumberRows();
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 resultobj = SWIG_From_int(static_cast< int >(result));
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10846 PyObject *resultobj = 0;
10847 wxGrid *arg1 = (wxGrid *) 0 ;
10848 int result;
10849 void *argp1 = 0 ;
10850 int res1 = 0 ;
10851 PyObject *swig_obj[1] ;
10852
10853 if (!args) SWIG_fail;
10854 swig_obj[0] = args;
10855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10856 if (!SWIG_IsOK(res1)) {
10857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10858 }
10859 arg1 = reinterpret_cast< wxGrid * >(argp1);
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = (int)(arg1)->GetNumberCols();
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = SWIG_From_int(static_cast< int >(result));
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj = 0;
10875 wxGrid *arg1 = (wxGrid *) 0 ;
10876 wxGridTableMessage *arg2 = 0 ;
10877 bool result;
10878 void *argp1 = 0 ;
10879 int res1 = 0 ;
10880 void *argp2 = 0 ;
10881 int res2 = 0 ;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 char * kwnames[] = {
10885 (char *) "self",(char *)"arg2", NULL
10886 };
10887
10888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10890 if (!SWIG_IsOK(res1)) {
10891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10892 }
10893 arg1 = reinterpret_cast< wxGrid * >(argp1);
10894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10895 if (!SWIG_IsOK(res2)) {
10896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10897 }
10898 if (!argp2) {
10899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10900 }
10901 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 {
10909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10910 }
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10918 PyObject *resultobj = 0;
10919 wxGrid *arg1 = (wxGrid *) 0 ;
10920 wxGridTableBase *result = 0 ;
10921 void *argp1 = 0 ;
10922 int res1 = 0 ;
10923 PyObject *swig_obj[1] ;
10924
10925 if (!args) SWIG_fail;
10926 swig_obj[0] = args;
10927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10928 if (!SWIG_IsOK(res1)) {
10929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10930 }
10931 arg1 = reinterpret_cast< wxGrid * >(argp1);
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10940 }
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxGrid *arg1 = (wxGrid *) 0 ;
10950 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10951 bool arg3 = (bool) false ;
10952 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10953 bool result;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int res2 = 0 ;
10957 bool val3 ;
10958 int ecode3 = 0 ;
10959 int val4 ;
10960 int ecode4 = 0 ;
10961 PyObject * obj0 = 0 ;
10962 PyObject * obj1 = 0 ;
10963 PyObject * obj2 = 0 ;
10964 PyObject * obj3 = 0 ;
10965 char * kwnames[] = {
10966 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10967 };
10968
10969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10973 }
10974 arg1 = reinterpret_cast< wxGrid * >(argp1);
10975 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10976 if (!SWIG_IsOK(res2)) {
10977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10978 }
10979 if (obj2) {
10980 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10981 if (!SWIG_IsOK(ecode3)) {
10982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10983 }
10984 arg3 = static_cast< bool >(val3);
10985 }
10986 if (obj3) {
10987 ecode4 = SWIG_AsVal_int(obj3, &val4);
10988 if (!SWIG_IsOK(ecode4)) {
10989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10990 }
10991 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10992 }
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10996 wxPyEndAllowThreads(__tstate);
10997 if (PyErr_Occurred()) SWIG_fail;
10998 }
10999 {
11000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11001 }
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11009 PyObject *resultobj = 0;
11010 wxGrid *arg1 = (wxGrid *) 0 ;
11011 void *argp1 = 0 ;
11012 int res1 = 0 ;
11013 PyObject *swig_obj[1] ;
11014
11015 if (!args) SWIG_fail;
11016 swig_obj[0] = args;
11017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11018 if (!SWIG_IsOK(res1)) {
11019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11020 }
11021 arg1 = reinterpret_cast< wxGrid * >(argp1);
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 (arg1)->ClearGrid();
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 resultobj = SWIG_Py_Void();
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 SWIGINTERN PyObject *_wrap_Grid_InsertRows(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_InsertRows",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_InsertRows" "', 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_InsertRows" "', 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_InsertRows" "', 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_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11082 }
11083 arg4 = static_cast< bool >(val4);
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (bool)(arg1)->InsertRows(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_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj = 0;
11102 wxGrid *arg1 = (wxGrid *) 0 ;
11103 int arg2 = (int) 1 ;
11104 bool arg3 = (bool) true ;
11105 bool result;
11106 void *argp1 = 0 ;
11107 int res1 = 0 ;
11108 int val2 ;
11109 int ecode2 = 0 ;
11110 bool val3 ;
11111 int ecode3 = 0 ;
11112 PyObject * obj0 = 0 ;
11113 PyObject * obj1 = 0 ;
11114 PyObject * obj2 = 0 ;
11115 char * kwnames[] = {
11116 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11117 };
11118
11119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11121 if (!SWIG_IsOK(res1)) {
11122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11123 }
11124 arg1 = reinterpret_cast< wxGrid * >(argp1);
11125 if (obj1) {
11126 ecode2 = SWIG_AsVal_int(obj1, &val2);
11127 if (!SWIG_IsOK(ecode2)) {
11128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11129 }
11130 arg2 = static_cast< int >(val2);
11131 }
11132 if (obj2) {
11133 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11134 if (!SWIG_IsOK(ecode3)) {
11135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11136 }
11137 arg3 = static_cast< bool >(val3);
11138 }
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (bool)(arg1)->AppendRows(arg2,arg3);
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 {
11146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11147 }
11148 return resultobj;
11149 fail:
11150 return NULL;
11151 }
11152
11153
11154 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj = 0;
11156 wxGrid *arg1 = (wxGrid *) 0 ;
11157 int arg2 = (int) 0 ;
11158 int arg3 = (int) 1 ;
11159 bool arg4 = (bool) true ;
11160 bool result;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 int val2 ;
11164 int ecode2 = 0 ;
11165 int val3 ;
11166 int ecode3 = 0 ;
11167 bool val4 ;
11168 int ecode4 = 0 ;
11169 PyObject * obj0 = 0 ;
11170 PyObject * obj1 = 0 ;
11171 PyObject * obj2 = 0 ;
11172 PyObject * obj3 = 0 ;
11173 char * kwnames[] = {
11174 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11175 };
11176
11177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11179 if (!SWIG_IsOK(res1)) {
11180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11181 }
11182 arg1 = reinterpret_cast< wxGrid * >(argp1);
11183 if (obj1) {
11184 ecode2 = SWIG_AsVal_int(obj1, &val2);
11185 if (!SWIG_IsOK(ecode2)) {
11186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11187 }
11188 arg2 = static_cast< int >(val2);
11189 }
11190 if (obj2) {
11191 ecode3 = SWIG_AsVal_int(obj2, &val3);
11192 if (!SWIG_IsOK(ecode3)) {
11193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11194 }
11195 arg3 = static_cast< int >(val3);
11196 }
11197 if (obj3) {
11198 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11199 if (!SWIG_IsOK(ecode4)) {
11200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11201 }
11202 arg4 = static_cast< bool >(val4);
11203 }
11204 {
11205 PyThreadState* __tstate = wxPyBeginAllowThreads();
11206 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
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_InsertCols(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_InsertCols",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_InsertCols" "', 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_InsertCols" "', 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_InsertCols" "', 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_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11266 }
11267 arg4 = static_cast< bool >(val4);
11268 }
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 result = (bool)(arg1)->InsertCols(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_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj = 0;
11286 wxGrid *arg1 = (wxGrid *) 0 ;
11287 int arg2 = (int) 1 ;
11288 bool arg3 = (bool) true ;
11289 bool result;
11290 void *argp1 = 0 ;
11291 int res1 = 0 ;
11292 int val2 ;
11293 int ecode2 = 0 ;
11294 bool val3 ;
11295 int ecode3 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 PyObject * obj2 = 0 ;
11299 char * kwnames[] = {
11300 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11301 };
11302
11303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11307 }
11308 arg1 = reinterpret_cast< wxGrid * >(argp1);
11309 if (obj1) {
11310 ecode2 = SWIG_AsVal_int(obj1, &val2);
11311 if (!SWIG_IsOK(ecode2)) {
11312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11313 }
11314 arg2 = static_cast< int >(val2);
11315 }
11316 if (obj2) {
11317 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11318 if (!SWIG_IsOK(ecode3)) {
11319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11320 }
11321 arg3 = static_cast< bool >(val3);
11322 }
11323 {
11324 PyThreadState* __tstate = wxPyBeginAllowThreads();
11325 result = (bool)(arg1)->AppendCols(arg2,arg3);
11326 wxPyEndAllowThreads(__tstate);
11327 if (PyErr_Occurred()) SWIG_fail;
11328 }
11329 {
11330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11331 }
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj = 0;
11340 wxGrid *arg1 = (wxGrid *) 0 ;
11341 int arg2 = (int) 0 ;
11342 int arg3 = (int) 1 ;
11343 bool arg4 = (bool) true ;
11344 bool result;
11345 void *argp1 = 0 ;
11346 int res1 = 0 ;
11347 int val2 ;
11348 int ecode2 = 0 ;
11349 int val3 ;
11350 int ecode3 = 0 ;
11351 bool val4 ;
11352 int ecode4 = 0 ;
11353 PyObject * obj0 = 0 ;
11354 PyObject * obj1 = 0 ;
11355 PyObject * obj2 = 0 ;
11356 PyObject * obj3 = 0 ;
11357 char * kwnames[] = {
11358 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11359 };
11360
11361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11363 if (!SWIG_IsOK(res1)) {
11364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11365 }
11366 arg1 = reinterpret_cast< wxGrid * >(argp1);
11367 if (obj1) {
11368 ecode2 = SWIG_AsVal_int(obj1, &val2);
11369 if (!SWIG_IsOK(ecode2)) {
11370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11371 }
11372 arg2 = static_cast< int >(val2);
11373 }
11374 if (obj2) {
11375 ecode3 = SWIG_AsVal_int(obj2, &val3);
11376 if (!SWIG_IsOK(ecode3)) {
11377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11378 }
11379 arg3 = static_cast< int >(val3);
11380 }
11381 if (obj3) {
11382 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11383 if (!SWIG_IsOK(ecode4)) {
11384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11385 }
11386 arg4 = static_cast< bool >(val4);
11387 }
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11391 wxPyEndAllowThreads(__tstate);
11392 if (PyErr_Occurred()) SWIG_fail;
11393 }
11394 {
11395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11396 }
11397 return resultobj;
11398 fail:
11399 return NULL;
11400 }
11401
11402
11403 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11404 PyObject *resultobj = 0;
11405 wxGrid *arg1 = (wxGrid *) 0 ;
11406 wxDC *arg2 = 0 ;
11407 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11408 void *argp1 = 0 ;
11409 int res1 = 0 ;
11410 void *argp2 = 0 ;
11411 int res2 = 0 ;
11412 void *argp3 = 0 ;
11413 int res3 = 0 ;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 char * kwnames[] = {
11418 (char *) "self",(char *) "dc",(char *) "attr", NULL
11419 };
11420
11421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11423 if (!SWIG_IsOK(res1)) {
11424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11425 }
11426 arg1 = reinterpret_cast< wxGrid * >(argp1);
11427 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11428 if (!SWIG_IsOK(res2)) {
11429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11430 }
11431 if (!argp2) {
11432 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11433 }
11434 arg2 = reinterpret_cast< wxDC * >(argp2);
11435 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11436 if (!SWIG_IsOK(res3)) {
11437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11438 }
11439 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_Py_Void();
11447 return resultobj;
11448 fail:
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11454 PyObject *resultobj = 0;
11455 wxGrid *arg1 = (wxGrid *) 0 ;
11456 wxDC *arg2 = 0 ;
11457 wxString *arg3 = 0 ;
11458 wxRect *arg4 = 0 ;
11459 int arg5 = (int) wxLEFT ;
11460 int arg6 = (int) wxTOP ;
11461 int arg7 = (int) wxHORIZONTAL ;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 void *argp2 = 0 ;
11465 int res2 = 0 ;
11466 bool temp3 = false ;
11467 wxRect temp4 ;
11468 int val5 ;
11469 int ecode5 = 0 ;
11470 int val6 ;
11471 int ecode6 = 0 ;
11472 int val7 ;
11473 int ecode7 = 0 ;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 PyObject * obj2 = 0 ;
11477 PyObject * obj3 = 0 ;
11478 PyObject * obj4 = 0 ;
11479 PyObject * obj5 = 0 ;
11480 PyObject * obj6 = 0 ;
11481 char * kwnames[] = {
11482 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11483 };
11484
11485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11487 if (!SWIG_IsOK(res1)) {
11488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11489 }
11490 arg1 = reinterpret_cast< wxGrid * >(argp1);
11491 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11492 if (!SWIG_IsOK(res2)) {
11493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11494 }
11495 if (!argp2) {
11496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11497 }
11498 arg2 = reinterpret_cast< wxDC * >(argp2);
11499 {
11500 arg3 = wxString_in_helper(obj2);
11501 if (arg3 == NULL) SWIG_fail;
11502 temp3 = true;
11503 }
11504 {
11505 arg4 = &temp4;
11506 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11507 }
11508 if (obj4) {
11509 ecode5 = SWIG_AsVal_int(obj4, &val5);
11510 if (!SWIG_IsOK(ecode5)) {
11511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11512 }
11513 arg5 = static_cast< int >(val5);
11514 }
11515 if (obj5) {
11516 ecode6 = SWIG_AsVal_int(obj5, &val6);
11517 if (!SWIG_IsOK(ecode6)) {
11518 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11519 }
11520 arg6 = static_cast< int >(val6);
11521 }
11522 if (obj6) {
11523 ecode7 = SWIG_AsVal_int(obj6, &val7);
11524 if (!SWIG_IsOK(ecode7)) {
11525 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11526 }
11527 arg7 = static_cast< int >(val7);
11528 }
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 resultobj = SWIG_Py_Void();
11536 {
11537 if (temp3)
11538 delete arg3;
11539 }
11540 return resultobj;
11541 fail:
11542 {
11543 if (temp3)
11544 delete arg3;
11545 }
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj = 0;
11552 wxGrid *arg1 = (wxGrid *) 0 ;
11553 wxDC *arg2 = 0 ;
11554 wxArrayString *arg3 = 0 ;
11555 long *arg4 = (long *) 0 ;
11556 long *arg5 = (long *) 0 ;
11557 void *argp1 = 0 ;
11558 int res1 = 0 ;
11559 void *argp2 = 0 ;
11560 int res2 = 0 ;
11561 bool temp3 = false ;
11562 long temp4 ;
11563 int res4 = SWIG_TMPOBJ ;
11564 long temp5 ;
11565 int res5 = SWIG_TMPOBJ ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 char * kwnames[] = {
11570 (char *) "self",(char *) "dc",(char *) "lines", NULL
11571 };
11572
11573 arg4 = &temp4;
11574 arg5 = &temp5;
11575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11577 if (!SWIG_IsOK(res1)) {
11578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11579 }
11580 arg1 = reinterpret_cast< wxGrid * >(argp1);
11581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11582 if (!SWIG_IsOK(res2)) {
11583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11584 }
11585 if (!argp2) {
11586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11587 }
11588 arg2 = reinterpret_cast< wxDC * >(argp2);
11589 {
11590 if (! PySequence_Check(obj2)) {
11591 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11592 SWIG_fail;
11593 }
11594 arg3 = new wxArrayString;
11595 temp3 = true;
11596 int i, len=PySequence_Length(obj2);
11597 for (i=0; i<len; i++) {
11598 PyObject* item = PySequence_GetItem(obj2, i);
11599 wxString* s = wxString_in_helper(item);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 arg3->Add(*s);
11602 delete s;
11603 Py_DECREF(item);
11604 }
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 resultobj = SWIG_Py_Void();
11613 if (SWIG_IsTmpObj(res4)) {
11614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11615 } else {
11616 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11618 }
11619 if (SWIG_IsTmpObj(res5)) {
11620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11621 } else {
11622 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11624 }
11625 {
11626 if (temp3) delete arg3;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp3) delete arg3;
11632 }
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxGrid *arg1 = (wxGrid *) 0 ;
11640 void *argp1 = 0 ;
11641 int res1 = 0 ;
11642 PyObject *swig_obj[1] ;
11643
11644 if (!args) SWIG_fail;
11645 swig_obj[0] = args;
11646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11649 }
11650 arg1 = reinterpret_cast< wxGrid * >(argp1);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 (arg1)->BeginBatch();
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 resultobj = SWIG_Py_Void();
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11665 PyObject *resultobj = 0;
11666 wxGrid *arg1 = (wxGrid *) 0 ;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 PyObject *swig_obj[1] ;
11670
11671 if (!args) SWIG_fail;
11672 swig_obj[0] = args;
11673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11674 if (!SWIG_IsOK(res1)) {
11675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11676 }
11677 arg1 = reinterpret_cast< wxGrid * >(argp1);
11678 {
11679 PyThreadState* __tstate = wxPyBeginAllowThreads();
11680 (arg1)->EndBatch();
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 resultobj = SWIG_Py_Void();
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11692 PyObject *resultobj = 0;
11693 wxGrid *arg1 = (wxGrid *) 0 ;
11694 int result;
11695 void *argp1 = 0 ;
11696 int res1 = 0 ;
11697 PyObject *swig_obj[1] ;
11698
11699 if (!args) SWIG_fail;
11700 swig_obj[0] = args;
11701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11702 if (!SWIG_IsOK(res1)) {
11703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11704 }
11705 arg1 = reinterpret_cast< wxGrid * >(argp1);
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (int)(arg1)->GetBatchCount();
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 resultobj = SWIG_From_int(static_cast< int >(result));
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720 PyObject *resultobj = 0;
11721 wxGrid *arg1 = (wxGrid *) 0 ;
11722 void *argp1 = 0 ;
11723 int res1 = 0 ;
11724 PyObject *swig_obj[1] ;
11725
11726 if (!args) SWIG_fail;
11727 swig_obj[0] = args;
11728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11729 if (!SWIG_IsOK(res1)) {
11730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11731 }
11732 arg1 = reinterpret_cast< wxGrid * >(argp1);
11733 {
11734 PyThreadState* __tstate = wxPyBeginAllowThreads();
11735 (arg1)->ForceRefresh();
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 resultobj = SWIG_Py_Void();
11740 return resultobj;
11741 fail:
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11747 PyObject *resultobj = 0;
11748 wxGrid *arg1 = (wxGrid *) 0 ;
11749 bool result;
11750 void *argp1 = 0 ;
11751 int res1 = 0 ;
11752 PyObject *swig_obj[1] ;
11753
11754 if (!args) SWIG_fail;
11755 swig_obj[0] = args;
11756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11757 if (!SWIG_IsOK(res1)) {
11758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11759 }
11760 arg1 = reinterpret_cast< wxGrid * >(argp1);
11761 {
11762 PyThreadState* __tstate = wxPyBeginAllowThreads();
11763 result = (bool)(arg1)->IsEditable();
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 {
11768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11769 }
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj = 0;
11778 wxGrid *arg1 = (wxGrid *) 0 ;
11779 bool arg2 ;
11780 void *argp1 = 0 ;
11781 int res1 = 0 ;
11782 bool val2 ;
11783 int ecode2 = 0 ;
11784 PyObject * obj0 = 0 ;
11785 PyObject * obj1 = 0 ;
11786 char * kwnames[] = {
11787 (char *) "self",(char *) "edit", NULL
11788 };
11789
11790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11792 if (!SWIG_IsOK(res1)) {
11793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11794 }
11795 arg1 = reinterpret_cast< wxGrid * >(argp1);
11796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11797 if (!SWIG_IsOK(ecode2)) {
11798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11799 }
11800 arg2 = static_cast< bool >(val2);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 (arg1)->EnableEditing(arg2);
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 resultobj = SWIG_Py_Void();
11808 return resultobj;
11809 fail:
11810 return NULL;
11811 }
11812
11813
11814 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11815 PyObject *resultobj = 0;
11816 wxGrid *arg1 = (wxGrid *) 0 ;
11817 bool arg2 = (bool) true ;
11818 void *argp1 = 0 ;
11819 int res1 = 0 ;
11820 bool val2 ;
11821 int ecode2 = 0 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 char * kwnames[] = {
11825 (char *) "self",(char *) "enable", NULL
11826 };
11827
11828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11832 }
11833 arg1 = reinterpret_cast< wxGrid * >(argp1);
11834 if (obj1) {
11835 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11836 if (!SWIG_IsOK(ecode2)) {
11837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11838 }
11839 arg2 = static_cast< bool >(val2);
11840 }
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 (arg1)->EnableCellEditControl(arg2);
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 resultobj = SWIG_Py_Void();
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11855 PyObject *resultobj = 0;
11856 wxGrid *arg1 = (wxGrid *) 0 ;
11857 void *argp1 = 0 ;
11858 int res1 = 0 ;
11859 PyObject *swig_obj[1] ;
11860
11861 if (!args) SWIG_fail;
11862 swig_obj[0] = args;
11863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11864 if (!SWIG_IsOK(res1)) {
11865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11866 }
11867 arg1 = reinterpret_cast< wxGrid * >(argp1);
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 (arg1)->DisableCellEditControl();
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 resultobj = SWIG_Py_Void();
11875 return resultobj;
11876 fail:
11877 return NULL;
11878 }
11879
11880
11881 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11882 PyObject *resultobj = 0;
11883 wxGrid *arg1 = (wxGrid *) 0 ;
11884 bool result;
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_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11894 }
11895 arg1 = reinterpret_cast< wxGrid * >(argp1);
11896 {
11897 PyThreadState* __tstate = wxPyBeginAllowThreads();
11898 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 {
11903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11904 }
11905 return resultobj;
11906 fail:
11907 return NULL;
11908 }
11909
11910
11911 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11912 PyObject *resultobj = 0;
11913 wxGrid *arg1 = (wxGrid *) 0 ;
11914 bool result;
11915 void *argp1 = 0 ;
11916 int res1 = 0 ;
11917 PyObject *swig_obj[1] ;
11918
11919 if (!args) SWIG_fail;
11920 swig_obj[0] = args;
11921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11922 if (!SWIG_IsOK(res1)) {
11923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11924 }
11925 arg1 = reinterpret_cast< wxGrid * >(argp1);
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 {
11933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11934 }
11935 return resultobj;
11936 fail:
11937 return NULL;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11942 PyObject *resultobj = 0;
11943 wxGrid *arg1 = (wxGrid *) 0 ;
11944 bool result;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 PyObject *swig_obj[1] ;
11948
11949 if (!args) SWIG_fail;
11950 swig_obj[0] = args;
11951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11954 }
11955 arg1 = reinterpret_cast< wxGrid * >(argp1);
11956 {
11957 PyThreadState* __tstate = wxPyBeginAllowThreads();
11958 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11964 }
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11972 PyObject *resultobj = 0;
11973 wxGrid *arg1 = (wxGrid *) 0 ;
11974 bool result;
11975 void *argp1 = 0 ;
11976 int res1 = 0 ;
11977 PyObject *swig_obj[1] ;
11978
11979 if (!args) SWIG_fail;
11980 swig_obj[0] = args;
11981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11982 if (!SWIG_IsOK(res1)) {
11983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11984 }
11985 arg1 = reinterpret_cast< wxGrid * >(argp1);
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 {
11993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11994 }
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002 PyObject *resultobj = 0;
12003 wxGrid *arg1 = (wxGrid *) 0 ;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject *swig_obj[1] ;
12007
12008 if (!args) SWIG_fail;
12009 swig_obj[0] = args;
12010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12013 }
12014 arg1 = reinterpret_cast< wxGrid * >(argp1);
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 (arg1)->ShowCellEditControl();
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_Py_Void();
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 PyObject *resultobj = 0;
12030 wxGrid *arg1 = (wxGrid *) 0 ;
12031 void *argp1 = 0 ;
12032 int res1 = 0 ;
12033 PyObject *swig_obj[1] ;
12034
12035 if (!args) SWIG_fail;
12036 swig_obj[0] = args;
12037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12038 if (!SWIG_IsOK(res1)) {
12039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12040 }
12041 arg1 = reinterpret_cast< wxGrid * >(argp1);
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 (arg1)->HideCellEditControl();
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_Py_Void();
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12056 PyObject *resultobj = 0;
12057 wxGrid *arg1 = (wxGrid *) 0 ;
12058 void *argp1 = 0 ;
12059 int res1 = 0 ;
12060 PyObject *swig_obj[1] ;
12061
12062 if (!args) SWIG_fail;
12063 swig_obj[0] = args;
12064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12065 if (!SWIG_IsOK(res1)) {
12066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12067 }
12068 arg1 = reinterpret_cast< wxGrid * >(argp1);
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 (arg1)->SaveEditControlValue();
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 resultobj = SWIG_Py_Void();
12076 return resultobj;
12077 fail:
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12083 PyObject *resultobj = 0;
12084 wxGrid *arg1 = (wxGrid *) 0 ;
12085 int arg2 ;
12086 int arg3 ;
12087 wxGridCellCoords result;
12088 void *argp1 = 0 ;
12089 int res1 = 0 ;
12090 int val2 ;
12091 int ecode2 = 0 ;
12092 int val3 ;
12093 int ecode3 = 0 ;
12094 PyObject * obj0 = 0 ;
12095 PyObject * obj1 = 0 ;
12096 PyObject * obj2 = 0 ;
12097 char * kwnames[] = {
12098 (char *) "self",(char *) "x",(char *) "y", NULL
12099 };
12100
12101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12103 if (!SWIG_IsOK(res1)) {
12104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12105 }
12106 arg1 = reinterpret_cast< wxGrid * >(argp1);
12107 ecode2 = SWIG_AsVal_int(obj1, &val2);
12108 if (!SWIG_IsOK(ecode2)) {
12109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12110 }
12111 arg2 = static_cast< int >(val2);
12112 ecode3 = SWIG_AsVal_int(obj2, &val3);
12113 if (!SWIG_IsOK(ecode3)) {
12114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12115 }
12116 arg3 = static_cast< int >(val3);
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = wxGrid_XYToCell(arg1,arg2,arg3);
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12124 return resultobj;
12125 fail:
12126 return NULL;
12127 }
12128
12129
12130 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12131 PyObject *resultobj = 0;
12132 wxGrid *arg1 = (wxGrid *) 0 ;
12133 int arg2 ;
12134 int result;
12135 void *argp1 = 0 ;
12136 int res1 = 0 ;
12137 int val2 ;
12138 int ecode2 = 0 ;
12139 PyObject * obj0 = 0 ;
12140 PyObject * obj1 = 0 ;
12141 char * kwnames[] = {
12142 (char *) "self",(char *) "y", NULL
12143 };
12144
12145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12147 if (!SWIG_IsOK(res1)) {
12148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12149 }
12150 arg1 = reinterpret_cast< wxGrid * >(argp1);
12151 ecode2 = SWIG_AsVal_int(obj1, &val2);
12152 if (!SWIG_IsOK(ecode2)) {
12153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12154 }
12155 arg2 = static_cast< int >(val2);
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (int)(arg1)->YToRow(arg2);
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 resultobj = SWIG_From_int(static_cast< int >(result));
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj = 0;
12171 wxGrid *arg1 = (wxGrid *) 0 ;
12172 int arg2 ;
12173 bool arg3 = (bool) false ;
12174 int result;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 int val2 ;
12178 int ecode2 = 0 ;
12179 bool val3 ;
12180 int ecode3 = 0 ;
12181 PyObject * obj0 = 0 ;
12182 PyObject * obj1 = 0 ;
12183 PyObject * obj2 = 0 ;
12184 char * kwnames[] = {
12185 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12186 };
12187
12188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12190 if (!SWIG_IsOK(res1)) {
12191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12192 }
12193 arg1 = reinterpret_cast< wxGrid * >(argp1);
12194 ecode2 = SWIG_AsVal_int(obj1, &val2);
12195 if (!SWIG_IsOK(ecode2)) {
12196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12197 }
12198 arg2 = static_cast< int >(val2);
12199 if (obj2) {
12200 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12201 if (!SWIG_IsOK(ecode3)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12203 }
12204 arg3 = static_cast< bool >(val3);
12205 }
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 result = (int)(arg1)->XToCol(arg2,arg3);
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 resultobj = SWIG_From_int(static_cast< int >(result));
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj = 0;
12221 wxGrid *arg1 = (wxGrid *) 0 ;
12222 int arg2 ;
12223 int result;
12224 void *argp1 = 0 ;
12225 int res1 = 0 ;
12226 int val2 ;
12227 int ecode2 = 0 ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 char * kwnames[] = {
12231 (char *) "self",(char *) "y", NULL
12232 };
12233
12234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12236 if (!SWIG_IsOK(res1)) {
12237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12238 }
12239 arg1 = reinterpret_cast< wxGrid * >(argp1);
12240 ecode2 = SWIG_AsVal_int(obj1, &val2);
12241 if (!SWIG_IsOK(ecode2)) {
12242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12243 }
12244 arg2 = static_cast< int >(val2);
12245 {
12246 PyThreadState* __tstate = wxPyBeginAllowThreads();
12247 result = (int)(arg1)->YToEdgeOfRow(arg2);
12248 wxPyEndAllowThreads(__tstate);
12249 if (PyErr_Occurred()) SWIG_fail;
12250 }
12251 resultobj = SWIG_From_int(static_cast< int >(result));
12252 return resultobj;
12253 fail:
12254 return NULL;
12255 }
12256
12257
12258 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12259 PyObject *resultobj = 0;
12260 wxGrid *arg1 = (wxGrid *) 0 ;
12261 int arg2 ;
12262 int result;
12263 void *argp1 = 0 ;
12264 int res1 = 0 ;
12265 int val2 ;
12266 int ecode2 = 0 ;
12267 PyObject * obj0 = 0 ;
12268 PyObject * obj1 = 0 ;
12269 char * kwnames[] = {
12270 (char *) "self",(char *) "x", NULL
12271 };
12272
12273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12275 if (!SWIG_IsOK(res1)) {
12276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12277 }
12278 arg1 = reinterpret_cast< wxGrid * >(argp1);
12279 ecode2 = SWIG_AsVal_int(obj1, &val2);
12280 if (!SWIG_IsOK(ecode2)) {
12281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12282 }
12283 arg2 = static_cast< int >(val2);
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (int)(arg1)->XToEdgeOfCol(arg2);
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_From_int(static_cast< int >(result));
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj = 0;
12299 wxGrid *arg1 = (wxGrid *) 0 ;
12300 int arg2 ;
12301 int arg3 ;
12302 wxRect result;
12303 void *argp1 = 0 ;
12304 int res1 = 0 ;
12305 int val2 ;
12306 int ecode2 = 0 ;
12307 int val3 ;
12308 int ecode3 = 0 ;
12309 PyObject * obj0 = 0 ;
12310 PyObject * obj1 = 0 ;
12311 PyObject * obj2 = 0 ;
12312 char * kwnames[] = {
12313 (char *) "self",(char *) "row",(char *) "col", NULL
12314 };
12315
12316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12318 if (!SWIG_IsOK(res1)) {
12319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12320 }
12321 arg1 = reinterpret_cast< wxGrid * >(argp1);
12322 ecode2 = SWIG_AsVal_int(obj1, &val2);
12323 if (!SWIG_IsOK(ecode2)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12325 }
12326 arg2 = static_cast< int >(val2);
12327 ecode3 = SWIG_AsVal_int(obj2, &val3);
12328 if (!SWIG_IsOK(ecode3)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12330 }
12331 arg3 = static_cast< int >(val3);
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 result = (arg1)->CellToRect(arg2,arg3);
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 PyObject *resultobj = 0;
12347 wxGrid *arg1 = (wxGrid *) 0 ;
12348 int result;
12349 void *argp1 = 0 ;
12350 int res1 = 0 ;
12351 PyObject *swig_obj[1] ;
12352
12353 if (!args) SWIG_fail;
12354 swig_obj[0] = args;
12355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12358 }
12359 arg1 = reinterpret_cast< wxGrid * >(argp1);
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)(arg1)->GetGridCursorRow();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_From_int(static_cast< int >(result));
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *resultobj = 0;
12375 wxGrid *arg1 = (wxGrid *) 0 ;
12376 int result;
12377 void *argp1 = 0 ;
12378 int res1 = 0 ;
12379 PyObject *swig_obj[1] ;
12380
12381 if (!args) SWIG_fail;
12382 swig_obj[0] = args;
12383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12386 }
12387 arg1 = reinterpret_cast< wxGrid * >(argp1);
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (int)(arg1)->GetGridCursorCol();
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 resultobj = SWIG_From_int(static_cast< int >(result));
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12402 PyObject *resultobj = 0;
12403 wxGrid *arg1 = (wxGrid *) 0 ;
12404 int arg2 ;
12405 int arg3 ;
12406 bool arg4 = (bool) true ;
12407 bool result;
12408 void *argp1 = 0 ;
12409 int res1 = 0 ;
12410 int val2 ;
12411 int ecode2 = 0 ;
12412 int val3 ;
12413 int ecode3 = 0 ;
12414 bool val4 ;
12415 int ecode4 = 0 ;
12416 PyObject * obj0 = 0 ;
12417 PyObject * obj1 = 0 ;
12418 PyObject * obj2 = 0 ;
12419 PyObject * obj3 = 0 ;
12420 char * kwnames[] = {
12421 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12422 };
12423
12424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12426 if (!SWIG_IsOK(res1)) {
12427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12428 }
12429 arg1 = reinterpret_cast< wxGrid * >(argp1);
12430 ecode2 = SWIG_AsVal_int(obj1, &val2);
12431 if (!SWIG_IsOK(ecode2)) {
12432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12433 }
12434 arg2 = static_cast< int >(val2);
12435 ecode3 = SWIG_AsVal_int(obj2, &val3);
12436 if (!SWIG_IsOK(ecode3)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12438 }
12439 arg3 = static_cast< int >(val3);
12440 if (obj3) {
12441 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12442 if (!SWIG_IsOK(ecode4)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12444 }
12445 arg4 = static_cast< bool >(val4);
12446 }
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12455 }
12456 return resultobj;
12457 fail:
12458 return NULL;
12459 }
12460
12461
12462 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12463 PyObject *resultobj = 0;
12464 wxGrid *arg1 = (wxGrid *) 0 ;
12465 int arg2 ;
12466 int arg3 ;
12467 void *argp1 = 0 ;
12468 int res1 = 0 ;
12469 int val2 ;
12470 int ecode2 = 0 ;
12471 int val3 ;
12472 int ecode3 = 0 ;
12473 PyObject * obj0 = 0 ;
12474 PyObject * obj1 = 0 ;
12475 PyObject * obj2 = 0 ;
12476 char * kwnames[] = {
12477 (char *) "self",(char *) "row",(char *) "col", NULL
12478 };
12479
12480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12482 if (!SWIG_IsOK(res1)) {
12483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12484 }
12485 arg1 = reinterpret_cast< wxGrid * >(argp1);
12486 ecode2 = SWIG_AsVal_int(obj1, &val2);
12487 if (!SWIG_IsOK(ecode2)) {
12488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12489 }
12490 arg2 = static_cast< int >(val2);
12491 ecode3 = SWIG_AsVal_int(obj2, &val3);
12492 if (!SWIG_IsOK(ecode3)) {
12493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12494 }
12495 arg3 = static_cast< int >(val3);
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 (arg1)->MakeCellVisible(arg2,arg3);
12499 wxPyEndAllowThreads(__tstate);
12500 if (PyErr_Occurred()) SWIG_fail;
12501 }
12502 resultobj = SWIG_Py_Void();
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12510 PyObject *resultobj = 0;
12511 wxGrid *arg1 = (wxGrid *) 0 ;
12512 int arg2 ;
12513 int arg3 ;
12514 void *argp1 = 0 ;
12515 int res1 = 0 ;
12516 int val2 ;
12517 int ecode2 = 0 ;
12518 int val3 ;
12519 int ecode3 = 0 ;
12520 PyObject * obj0 = 0 ;
12521 PyObject * obj1 = 0 ;
12522 PyObject * obj2 = 0 ;
12523 char * kwnames[] = {
12524 (char *) "self",(char *) "row",(char *) "col", NULL
12525 };
12526
12527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12531 }
12532 arg1 = reinterpret_cast< wxGrid * >(argp1);
12533 ecode2 = SWIG_AsVal_int(obj1, &val2);
12534 if (!SWIG_IsOK(ecode2)) {
12535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12536 }
12537 arg2 = static_cast< int >(val2);
12538 ecode3 = SWIG_AsVal_int(obj2, &val3);
12539 if (!SWIG_IsOK(ecode3)) {
12540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12541 }
12542 arg3 = static_cast< int >(val3);
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 (arg1)->SetGridCursor(arg2,arg3);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_Py_Void();
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj = 0;
12558 wxGrid *arg1 = (wxGrid *) 0 ;
12559 bool arg2 ;
12560 bool result;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 bool val2 ;
12564 int ecode2 = 0 ;
12565 PyObject * obj0 = 0 ;
12566 PyObject * obj1 = 0 ;
12567 char * kwnames[] = {
12568 (char *) "self",(char *) "expandSelection", NULL
12569 };
12570
12571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12573 if (!SWIG_IsOK(res1)) {
12574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12575 }
12576 arg1 = reinterpret_cast< wxGrid * >(argp1);
12577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12578 if (!SWIG_IsOK(ecode2)) {
12579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12580 }
12581 arg2 = static_cast< bool >(val2);
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 result = (bool)(arg1)->MoveCursorUp(arg2);
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 {
12589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12590 }
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12598 PyObject *resultobj = 0;
12599 wxGrid *arg1 = (wxGrid *) 0 ;
12600 bool arg2 ;
12601 bool result;
12602 void *argp1 = 0 ;
12603 int res1 = 0 ;
12604 bool val2 ;
12605 int ecode2 = 0 ;
12606 PyObject * obj0 = 0 ;
12607 PyObject * obj1 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "self",(char *) "expandSelection", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12616 }
12617 arg1 = reinterpret_cast< wxGrid * >(argp1);
12618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12619 if (!SWIG_IsOK(ecode2)) {
12620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12621 }
12622 arg2 = static_cast< bool >(val2);
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (bool)(arg1)->MoveCursorDown(arg2);
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 {
12630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12631 }
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 wxGrid *arg1 = (wxGrid *) 0 ;
12641 bool arg2 ;
12642 bool result;
12643 void *argp1 = 0 ;
12644 int res1 = 0 ;
12645 bool val2 ;
12646 int ecode2 = 0 ;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "self",(char *) "expandSelection", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12655 if (!SWIG_IsOK(res1)) {
12656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12657 }
12658 arg1 = reinterpret_cast< wxGrid * >(argp1);
12659 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12660 if (!SWIG_IsOK(ecode2)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12662 }
12663 arg2 = static_cast< bool >(val2);
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (bool)(arg1)->MoveCursorLeft(arg2);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12672 }
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj = 0;
12681 wxGrid *arg1 = (wxGrid *) 0 ;
12682 bool arg2 ;
12683 bool result;
12684 void *argp1 = 0 ;
12685 int res1 = 0 ;
12686 bool val2 ;
12687 int ecode2 = 0 ;
12688 PyObject * obj0 = 0 ;
12689 PyObject * obj1 = 0 ;
12690 char * kwnames[] = {
12691 (char *) "self",(char *) "expandSelection", NULL
12692 };
12693
12694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12698 }
12699 arg1 = reinterpret_cast< wxGrid * >(argp1);
12700 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12703 }
12704 arg2 = static_cast< bool >(val2);
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 result = (bool)(arg1)->MoveCursorRight(arg2);
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 {
12712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12713 }
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12721 PyObject *resultobj = 0;
12722 wxGrid *arg1 = (wxGrid *) 0 ;
12723 bool result;
12724 void *argp1 = 0 ;
12725 int res1 = 0 ;
12726 PyObject *swig_obj[1] ;
12727
12728 if (!args) SWIG_fail;
12729 swig_obj[0] = args;
12730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12731 if (!SWIG_IsOK(res1)) {
12732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12733 }
12734 arg1 = reinterpret_cast< wxGrid * >(argp1);
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (bool)(arg1)->MovePageDown();
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12743 }
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12751 PyObject *resultobj = 0;
12752 wxGrid *arg1 = (wxGrid *) 0 ;
12753 bool result;
12754 void *argp1 = 0 ;
12755 int res1 = 0 ;
12756 PyObject *swig_obj[1] ;
12757
12758 if (!args) SWIG_fail;
12759 swig_obj[0] = args;
12760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12761 if (!SWIG_IsOK(res1)) {
12762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12763 }
12764 arg1 = reinterpret_cast< wxGrid * >(argp1);
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (bool)(arg1)->MovePageUp();
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12773 }
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12781 PyObject *resultobj = 0;
12782 wxGrid *arg1 = (wxGrid *) 0 ;
12783 bool arg2 ;
12784 bool result;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 bool val2 ;
12788 int ecode2 = 0 ;
12789 PyObject * obj0 = 0 ;
12790 PyObject * obj1 = 0 ;
12791 char * kwnames[] = {
12792 (char *) "self",(char *) "expandSelection", NULL
12793 };
12794
12795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12797 if (!SWIG_IsOK(res1)) {
12798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12799 }
12800 arg1 = reinterpret_cast< wxGrid * >(argp1);
12801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12802 if (!SWIG_IsOK(ecode2)) {
12803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12804 }
12805 arg2 = static_cast< bool >(val2);
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12814 }
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12822 PyObject *resultobj = 0;
12823 wxGrid *arg1 = (wxGrid *) 0 ;
12824 bool arg2 ;
12825 bool result;
12826 void *argp1 = 0 ;
12827 int res1 = 0 ;
12828 bool val2 ;
12829 int ecode2 = 0 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 char * kwnames[] = {
12833 (char *) "self",(char *) "expandSelection", NULL
12834 };
12835
12836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12840 }
12841 arg1 = reinterpret_cast< wxGrid * >(argp1);
12842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12843 if (!SWIG_IsOK(ecode2)) {
12844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12845 }
12846 arg2 = static_cast< bool >(val2);
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12850 wxPyEndAllowThreads(__tstate);
12851 if (PyErr_Occurred()) SWIG_fail;
12852 }
12853 {
12854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12863 PyObject *resultobj = 0;
12864 wxGrid *arg1 = (wxGrid *) 0 ;
12865 bool arg2 ;
12866 bool result;
12867 void *argp1 = 0 ;
12868 int res1 = 0 ;
12869 bool val2 ;
12870 int ecode2 = 0 ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "self",(char *) "expandSelection", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12879 if (!SWIG_IsOK(res1)) {
12880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12881 }
12882 arg1 = reinterpret_cast< wxGrid * >(argp1);
12883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12884 if (!SWIG_IsOK(ecode2)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12886 }
12887 arg2 = static_cast< bool >(val2);
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 {
12895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12896 }
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj = 0;
12905 wxGrid *arg1 = (wxGrid *) 0 ;
12906 bool arg2 ;
12907 bool result;
12908 void *argp1 = 0 ;
12909 int res1 = 0 ;
12910 bool val2 ;
12911 int ecode2 = 0 ;
12912 PyObject * obj0 = 0 ;
12913 PyObject * obj1 = 0 ;
12914 char * kwnames[] = {
12915 (char *) "self",(char *) "expandSelection", NULL
12916 };
12917
12918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12922 }
12923 arg1 = reinterpret_cast< wxGrid * >(argp1);
12924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12925 if (!SWIG_IsOK(ecode2)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12927 }
12928 arg2 = static_cast< bool >(val2);
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12932 wxPyEndAllowThreads(__tstate);
12933 if (PyErr_Occurred()) SWIG_fail;
12934 }
12935 {
12936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12937 }
12938 return resultobj;
12939 fail:
12940 return NULL;
12941 }
12942
12943
12944 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12945 PyObject *resultobj = 0;
12946 wxGrid *arg1 = (wxGrid *) 0 ;
12947 int result;
12948 void *argp1 = 0 ;
12949 int res1 = 0 ;
12950 PyObject *swig_obj[1] ;
12951
12952 if (!args) SWIG_fail;
12953 swig_obj[0] = args;
12954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12955 if (!SWIG_IsOK(res1)) {
12956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12957 }
12958 arg1 = reinterpret_cast< wxGrid * >(argp1);
12959 {
12960 PyThreadState* __tstate = wxPyBeginAllowThreads();
12961 result = (int)(arg1)->GetDefaultRowLabelSize();
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 resultobj = SWIG_From_int(static_cast< int >(result));
12966 return resultobj;
12967 fail:
12968 return NULL;
12969 }
12970
12971
12972 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12973 PyObject *resultobj = 0;
12974 wxGrid *arg1 = (wxGrid *) 0 ;
12975 int result;
12976 void *argp1 = 0 ;
12977 int res1 = 0 ;
12978 PyObject *swig_obj[1] ;
12979
12980 if (!args) SWIG_fail;
12981 swig_obj[0] = args;
12982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12983 if (!SWIG_IsOK(res1)) {
12984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12985 }
12986 arg1 = reinterpret_cast< wxGrid * >(argp1);
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 result = (int)(arg1)->GetRowLabelSize();
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 resultobj = SWIG_From_int(static_cast< int >(result));
12994 return resultobj;
12995 fail:
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *resultobj = 0;
13002 wxGrid *arg1 = (wxGrid *) 0 ;
13003 int result;
13004 void *argp1 = 0 ;
13005 int res1 = 0 ;
13006 PyObject *swig_obj[1] ;
13007
13008 if (!args) SWIG_fail;
13009 swig_obj[0] = args;
13010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13011 if (!SWIG_IsOK(res1)) {
13012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13013 }
13014 arg1 = reinterpret_cast< wxGrid * >(argp1);
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (int)(arg1)->GetDefaultColLabelSize();
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 resultobj = SWIG_From_int(static_cast< int >(result));
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13029 PyObject *resultobj = 0;
13030 wxGrid *arg1 = (wxGrid *) 0 ;
13031 int result;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 PyObject *swig_obj[1] ;
13035
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_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13041 }
13042 arg1 = reinterpret_cast< wxGrid * >(argp1);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (int)(arg1)->GetColLabelSize();
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 resultobj = SWIG_From_int(static_cast< int >(result));
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *resultobj = 0;
13058 wxGrid *arg1 = (wxGrid *) 0 ;
13059 wxColour result;
13060 void *argp1 = 0 ;
13061 int res1 = 0 ;
13062 PyObject *swig_obj[1] ;
13063
13064 if (!args) SWIG_fail;
13065 swig_obj[0] = args;
13066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13067 if (!SWIG_IsOK(res1)) {
13068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13069 }
13070 arg1 = reinterpret_cast< wxGrid * >(argp1);
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 result = (arg1)->GetLabelBackgroundColour();
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *resultobj = 0;
13086 wxGrid *arg1 = (wxGrid *) 0 ;
13087 wxColour result;
13088 void *argp1 = 0 ;
13089 int res1 = 0 ;
13090 PyObject *swig_obj[1] ;
13091
13092 if (!args) SWIG_fail;
13093 swig_obj[0] = args;
13094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13097 }
13098 arg1 = reinterpret_cast< wxGrid * >(argp1);
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = (arg1)->GetLabelTextColour();
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13113 PyObject *resultobj = 0;
13114 wxGrid *arg1 = (wxGrid *) 0 ;
13115 wxFont result;
13116 void *argp1 = 0 ;
13117 int res1 = 0 ;
13118 PyObject *swig_obj[1] ;
13119
13120 if (!args) SWIG_fail;
13121 swig_obj[0] = args;
13122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13123 if (!SWIG_IsOK(res1)) {
13124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13125 }
13126 arg1 = reinterpret_cast< wxGrid * >(argp1);
13127 {
13128 PyThreadState* __tstate = wxPyBeginAllowThreads();
13129 result = (arg1)->GetLabelFont();
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13134 return resultobj;
13135 fail:
13136 return NULL;
13137 }
13138
13139
13140 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13141 PyObject *resultobj = 0;
13142 wxGrid *arg1 = (wxGrid *) 0 ;
13143 int *arg2 = (int *) 0 ;
13144 int *arg3 = (int *) 0 ;
13145 void *argp1 = 0 ;
13146 int res1 = 0 ;
13147 int temp2 ;
13148 int res2 = SWIG_TMPOBJ ;
13149 int temp3 ;
13150 int res3 = SWIG_TMPOBJ ;
13151 PyObject *swig_obj[1] ;
13152
13153 arg2 = &temp2;
13154 arg3 = &temp3;
13155 if (!args) SWIG_fail;
13156 swig_obj[0] = args;
13157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13158 if (!SWIG_IsOK(res1)) {
13159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13160 }
13161 arg1 = reinterpret_cast< wxGrid * >(argp1);
13162 {
13163 PyThreadState* __tstate = wxPyBeginAllowThreads();
13164 (arg1)->GetRowLabelAlignment(arg2,arg3);
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 resultobj = SWIG_Py_Void();
13169 if (SWIG_IsTmpObj(res2)) {
13170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13171 } else {
13172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13174 }
13175 if (SWIG_IsTmpObj(res3)) {
13176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13177 } else {
13178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13188 PyObject *resultobj = 0;
13189 wxGrid *arg1 = (wxGrid *) 0 ;
13190 int *arg2 = (int *) 0 ;
13191 int *arg3 = (int *) 0 ;
13192 void *argp1 = 0 ;
13193 int res1 = 0 ;
13194 int temp2 ;
13195 int res2 = SWIG_TMPOBJ ;
13196 int temp3 ;
13197 int res3 = SWIG_TMPOBJ ;
13198 PyObject *swig_obj[1] ;
13199
13200 arg2 = &temp2;
13201 arg3 = &temp3;
13202 if (!args) SWIG_fail;
13203 swig_obj[0] = args;
13204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13205 if (!SWIG_IsOK(res1)) {
13206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13207 }
13208 arg1 = reinterpret_cast< wxGrid * >(argp1);
13209 {
13210 PyThreadState* __tstate = wxPyBeginAllowThreads();
13211 (arg1)->GetColLabelAlignment(arg2,arg3);
13212 wxPyEndAllowThreads(__tstate);
13213 if (PyErr_Occurred()) SWIG_fail;
13214 }
13215 resultobj = SWIG_Py_Void();
13216 if (SWIG_IsTmpObj(res2)) {
13217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13218 } else {
13219 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13221 }
13222 if (SWIG_IsTmpObj(res3)) {
13223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13224 } else {
13225 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13227 }
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235 PyObject *resultobj = 0;
13236 wxGrid *arg1 = (wxGrid *) 0 ;
13237 int result;
13238 void *argp1 = 0 ;
13239 int res1 = 0 ;
13240 PyObject *swig_obj[1] ;
13241
13242 if (!args) SWIG_fail;
13243 swig_obj[0] = args;
13244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13245 if (!SWIG_IsOK(res1)) {
13246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13247 }
13248 arg1 = reinterpret_cast< wxGrid * >(argp1);
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 result = (int)(arg1)->GetColLabelTextOrientation();
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 resultobj = SWIG_From_int(static_cast< int >(result));
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj = 0;
13264 wxGrid *arg1 = (wxGrid *) 0 ;
13265 int arg2 ;
13266 wxString result;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 int val2 ;
13270 int ecode2 = 0 ;
13271 PyObject * obj0 = 0 ;
13272 PyObject * obj1 = 0 ;
13273 char * kwnames[] = {
13274 (char *) "self",(char *) "row", NULL
13275 };
13276
13277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13279 if (!SWIG_IsOK(res1)) {
13280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13281 }
13282 arg1 = reinterpret_cast< wxGrid * >(argp1);
13283 ecode2 = SWIG_AsVal_int(obj1, &val2);
13284 if (!SWIG_IsOK(ecode2)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13286 }
13287 arg2 = static_cast< int >(val2);
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (arg1)->GetRowLabelValue(arg2);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 {
13295 #if wxUSE_UNICODE
13296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13297 #else
13298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13299 #endif
13300 }
13301 return resultobj;
13302 fail:
13303 return NULL;
13304 }
13305
13306
13307 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13308 PyObject *resultobj = 0;
13309 wxGrid *arg1 = (wxGrid *) 0 ;
13310 int arg2 ;
13311 wxString result;
13312 void *argp1 = 0 ;
13313 int res1 = 0 ;
13314 int val2 ;
13315 int ecode2 = 0 ;
13316 PyObject * obj0 = 0 ;
13317 PyObject * obj1 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "self",(char *) "col", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13326 }
13327 arg1 = reinterpret_cast< wxGrid * >(argp1);
13328 ecode2 = SWIG_AsVal_int(obj1, &val2);
13329 if (!SWIG_IsOK(ecode2)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13331 }
13332 arg2 = static_cast< int >(val2);
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 result = (arg1)->GetColLabelValue(arg2);
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 {
13340 #if wxUSE_UNICODE
13341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13342 #else
13343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13344 #endif
13345 }
13346 return resultobj;
13347 fail:
13348 return NULL;
13349 }
13350
13351
13352 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13353 PyObject *resultobj = 0;
13354 wxGrid *arg1 = (wxGrid *) 0 ;
13355 wxColour result;
13356 void *argp1 = 0 ;
13357 int res1 = 0 ;
13358 PyObject *swig_obj[1] ;
13359
13360 if (!args) SWIG_fail;
13361 swig_obj[0] = args;
13362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13363 if (!SWIG_IsOK(res1)) {
13364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13365 }
13366 arg1 = reinterpret_cast< wxGrid * >(argp1);
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = (arg1)->GetGridLineColour();
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13381 PyObject *resultobj = 0;
13382 wxGrid *arg1 = (wxGrid *) 0 ;
13383 wxPen result;
13384 void *argp1 = 0 ;
13385 int res1 = 0 ;
13386 PyObject *swig_obj[1] ;
13387
13388 if (!args) SWIG_fail;
13389 swig_obj[0] = args;
13390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13391 if (!SWIG_IsOK(res1)) {
13392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13393 }
13394 arg1 = reinterpret_cast< wxGrid * >(argp1);
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (arg1)->GetDefaultGridLinePen();
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj = 0;
13410 wxGrid *arg1 = (wxGrid *) 0 ;
13411 int arg2 ;
13412 wxPen result;
13413 void *argp1 = 0 ;
13414 int res1 = 0 ;
13415 int val2 ;
13416 int ecode2 = 0 ;
13417 PyObject * obj0 = 0 ;
13418 PyObject * obj1 = 0 ;
13419 char * kwnames[] = {
13420 (char *) "self",(char *) "row", NULL
13421 };
13422
13423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13425 if (!SWIG_IsOK(res1)) {
13426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13427 }
13428 arg1 = reinterpret_cast< wxGrid * >(argp1);
13429 ecode2 = SWIG_AsVal_int(obj1, &val2);
13430 if (!SWIG_IsOK(ecode2)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13432 }
13433 arg2 = static_cast< int >(val2);
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 result = (arg1)->GetRowGridLinePen(arg2);
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13448 PyObject *resultobj = 0;
13449 wxGrid *arg1 = (wxGrid *) 0 ;
13450 int arg2 ;
13451 wxPen result;
13452 void *argp1 = 0 ;
13453 int res1 = 0 ;
13454 int val2 ;
13455 int ecode2 = 0 ;
13456 PyObject * obj0 = 0 ;
13457 PyObject * obj1 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "col", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13466 }
13467 arg1 = reinterpret_cast< wxGrid * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (arg1)->GetColGridLinePen(arg2);
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13480 return resultobj;
13481 fail:
13482 return NULL;
13483 }
13484
13485
13486 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13487 PyObject *resultobj = 0;
13488 wxGrid *arg1 = (wxGrid *) 0 ;
13489 wxColour result;
13490 void *argp1 = 0 ;
13491 int res1 = 0 ;
13492 PyObject *swig_obj[1] ;
13493
13494 if (!args) SWIG_fail;
13495 swig_obj[0] = args;
13496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13497 if (!SWIG_IsOK(res1)) {
13498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13499 }
13500 arg1 = reinterpret_cast< wxGrid * >(argp1);
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = (arg1)->GetCellHighlightColour();
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13515 PyObject *resultobj = 0;
13516 wxGrid *arg1 = (wxGrid *) 0 ;
13517 int result;
13518 void *argp1 = 0 ;
13519 int res1 = 0 ;
13520 PyObject *swig_obj[1] ;
13521
13522 if (!args) SWIG_fail;
13523 swig_obj[0] = args;
13524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13525 if (!SWIG_IsOK(res1)) {
13526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13527 }
13528 arg1 = reinterpret_cast< wxGrid * >(argp1);
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (int)(arg1)->GetCellHighlightPenWidth();
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 resultobj = SWIG_From_int(static_cast< int >(result));
13536 return resultobj;
13537 fail:
13538 return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543 PyObject *resultobj = 0;
13544 wxGrid *arg1 = (wxGrid *) 0 ;
13545 int result;
13546 void *argp1 = 0 ;
13547 int res1 = 0 ;
13548 PyObject *swig_obj[1] ;
13549
13550 if (!args) SWIG_fail;
13551 swig_obj[0] = args;
13552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13553 if (!SWIG_IsOK(res1)) {
13554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13555 }
13556 arg1 = reinterpret_cast< wxGrid * >(argp1);
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = (int)(arg1)->GetCellHighlightROPenWidth();
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 resultobj = SWIG_From_int(static_cast< int >(result));
13564 return resultobj;
13565 fail:
13566 return NULL;
13567 }
13568
13569
13570 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj = 0;
13572 wxGrid *arg1 = (wxGrid *) 0 ;
13573 int arg2 ;
13574 void *argp1 = 0 ;
13575 int res1 = 0 ;
13576 int val2 ;
13577 int ecode2 = 0 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 char * kwnames[] = {
13581 (char *) "self",(char *) "width", NULL
13582 };
13583
13584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13586 if (!SWIG_IsOK(res1)) {
13587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13588 }
13589 arg1 = reinterpret_cast< wxGrid * >(argp1);
13590 ecode2 = SWIG_AsVal_int(obj1, &val2);
13591 if (!SWIG_IsOK(ecode2)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13593 }
13594 arg2 = static_cast< int >(val2);
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 (arg1)->SetRowLabelSize(arg2);
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 resultobj = SWIG_Py_Void();
13602 return resultobj;
13603 fail:
13604 return NULL;
13605 }
13606
13607
13608 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13609 PyObject *resultobj = 0;
13610 wxGrid *arg1 = (wxGrid *) 0 ;
13611 int arg2 ;
13612 void *argp1 = 0 ;
13613 int res1 = 0 ;
13614 int val2 ;
13615 int ecode2 = 0 ;
13616 PyObject * obj0 = 0 ;
13617 PyObject * obj1 = 0 ;
13618 char * kwnames[] = {
13619 (char *) "self",(char *) "height", NULL
13620 };
13621
13622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13624 if (!SWIG_IsOK(res1)) {
13625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13626 }
13627 arg1 = reinterpret_cast< wxGrid * >(argp1);
13628 ecode2 = SWIG_AsVal_int(obj1, &val2);
13629 if (!SWIG_IsOK(ecode2)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13631 }
13632 arg2 = static_cast< int >(val2);
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 (arg1)->SetColLabelSize(arg2);
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_Py_Void();
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj = 0;
13648 wxGrid *arg1 = (wxGrid *) 0 ;
13649 wxColour *arg2 = 0 ;
13650 void *argp1 = 0 ;
13651 int res1 = 0 ;
13652 wxColour temp2 ;
13653 PyObject * obj0 = 0 ;
13654 PyObject * obj1 = 0 ;
13655 char * kwnames[] = {
13656 (char *) "self",(char *)"arg2", NULL
13657 };
13658
13659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13661 if (!SWIG_IsOK(res1)) {
13662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13663 }
13664 arg1 = reinterpret_cast< wxGrid * >(argp1);
13665 {
13666 arg2 = &temp2;
13667 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13668 }
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_Py_Void();
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxGrid *arg1 = (wxGrid *) 0 ;
13685 wxColour *arg2 = 0 ;
13686 void *argp1 = 0 ;
13687 int res1 = 0 ;
13688 wxColour temp2 ;
13689 PyObject * obj0 = 0 ;
13690 PyObject * obj1 = 0 ;
13691 char * kwnames[] = {
13692 (char *) "self",(char *)"arg2", NULL
13693 };
13694
13695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13697 if (!SWIG_IsOK(res1)) {
13698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13699 }
13700 arg1 = reinterpret_cast< wxGrid * >(argp1);
13701 {
13702 arg2 = &temp2;
13703 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13704 }
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13708 wxPyEndAllowThreads(__tstate);
13709 if (PyErr_Occurred()) SWIG_fail;
13710 }
13711 resultobj = SWIG_Py_Void();
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj = 0;
13720 wxGrid *arg1 = (wxGrid *) 0 ;
13721 wxFont *arg2 = 0 ;
13722 void *argp1 = 0 ;
13723 int res1 = 0 ;
13724 void *argp2 = 0 ;
13725 int res2 = 0 ;
13726 PyObject * obj0 = 0 ;
13727 PyObject * obj1 = 0 ;
13728 char * kwnames[] = {
13729 (char *) "self",(char *)"arg2", NULL
13730 };
13731
13732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13734 if (!SWIG_IsOK(res1)) {
13735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13736 }
13737 arg1 = reinterpret_cast< wxGrid * >(argp1);
13738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13739 if (!SWIG_IsOK(res2)) {
13740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13741 }
13742 if (!argp2) {
13743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13744 }
13745 arg2 = reinterpret_cast< wxFont * >(argp2);
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 (arg1)->SetLabelFont((wxFont const &)*arg2);
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 resultobj = SWIG_Py_Void();
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 wxGrid *arg1 = (wxGrid *) 0 ;
13762 int arg2 ;
13763 int arg3 ;
13764 void *argp1 = 0 ;
13765 int res1 = 0 ;
13766 int val2 ;
13767 int ecode2 = 0 ;
13768 int val3 ;
13769 int ecode3 = 0 ;
13770 PyObject * obj0 = 0 ;
13771 PyObject * obj1 = 0 ;
13772 PyObject * obj2 = 0 ;
13773 char * kwnames[] = {
13774 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13775 };
13776
13777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13779 if (!SWIG_IsOK(res1)) {
13780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13781 }
13782 arg1 = reinterpret_cast< wxGrid * >(argp1);
13783 ecode2 = SWIG_AsVal_int(obj1, &val2);
13784 if (!SWIG_IsOK(ecode2)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13786 }
13787 arg2 = static_cast< int >(val2);
13788 ecode3 = SWIG_AsVal_int(obj2, &val3);
13789 if (!SWIG_IsOK(ecode3)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13791 }
13792 arg3 = static_cast< int >(val3);
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 (arg1)->SetRowLabelAlignment(arg2,arg3);
13796 wxPyEndAllowThreads(__tstate);
13797 if (PyErr_Occurred()) SWIG_fail;
13798 }
13799 resultobj = SWIG_Py_Void();
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj = 0;
13808 wxGrid *arg1 = (wxGrid *) 0 ;
13809 int arg2 ;
13810 int arg3 ;
13811 void *argp1 = 0 ;
13812 int res1 = 0 ;
13813 int val2 ;
13814 int ecode2 = 0 ;
13815 int val3 ;
13816 int ecode3 = 0 ;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 char * kwnames[] = {
13821 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13822 };
13823
13824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13826 if (!SWIG_IsOK(res1)) {
13827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13828 }
13829 arg1 = reinterpret_cast< wxGrid * >(argp1);
13830 ecode2 = SWIG_AsVal_int(obj1, &val2);
13831 if (!SWIG_IsOK(ecode2)) {
13832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13833 }
13834 arg2 = static_cast< int >(val2);
13835 ecode3 = SWIG_AsVal_int(obj2, &val3);
13836 if (!SWIG_IsOK(ecode3)) {
13837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13838 }
13839 arg3 = static_cast< int >(val3);
13840 {
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 (arg1)->SetColLabelAlignment(arg2,arg3);
13843 wxPyEndAllowThreads(__tstate);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 }
13846 resultobj = SWIG_Py_Void();
13847 return resultobj;
13848 fail:
13849 return NULL;
13850 }
13851
13852
13853 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj = 0;
13855 wxGrid *arg1 = (wxGrid *) 0 ;
13856 int arg2 ;
13857 void *argp1 = 0 ;
13858 int res1 = 0 ;
13859 int val2 ;
13860 int ecode2 = 0 ;
13861 PyObject * obj0 = 0 ;
13862 PyObject * obj1 = 0 ;
13863 char * kwnames[] = {
13864 (char *) "self",(char *) "textOrientation", NULL
13865 };
13866
13867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13869 if (!SWIG_IsOK(res1)) {
13870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13871 }
13872 arg1 = reinterpret_cast< wxGrid * >(argp1);
13873 ecode2 = SWIG_AsVal_int(obj1, &val2);
13874 if (!SWIG_IsOK(ecode2)) {
13875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13876 }
13877 arg2 = static_cast< int >(val2);
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 (arg1)->SetColLabelTextOrientation(arg2);
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 resultobj = SWIG_Py_Void();
13885 return resultobj;
13886 fail:
13887 return NULL;
13888 }
13889
13890
13891 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 wxGrid *arg1 = (wxGrid *) 0 ;
13894 int arg2 ;
13895 wxString *arg3 = 0 ;
13896 void *argp1 = 0 ;
13897 int res1 = 0 ;
13898 int val2 ;
13899 int ecode2 = 0 ;
13900 bool temp3 = false ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "row",(char *)"arg3", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13912 }
13913 arg1 = reinterpret_cast< wxGrid * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 {
13920 arg3 = wxString_in_helper(obj2);
13921 if (arg3 == NULL) SWIG_fail;
13922 temp3 = true;
13923 }
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_Py_Void();
13931 {
13932 if (temp3)
13933 delete arg3;
13934 }
13935 return resultobj;
13936 fail:
13937 {
13938 if (temp3)
13939 delete arg3;
13940 }
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj = 0;
13947 wxGrid *arg1 = (wxGrid *) 0 ;
13948 int arg2 ;
13949 wxString *arg3 = 0 ;
13950 void *argp1 = 0 ;
13951 int res1 = 0 ;
13952 int val2 ;
13953 int ecode2 = 0 ;
13954 bool temp3 = false ;
13955 PyObject * obj0 = 0 ;
13956 PyObject * obj1 = 0 ;
13957 PyObject * obj2 = 0 ;
13958 char * kwnames[] = {
13959 (char *) "self",(char *) "col",(char *)"arg3", NULL
13960 };
13961
13962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13964 if (!SWIG_IsOK(res1)) {
13965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13966 }
13967 arg1 = reinterpret_cast< wxGrid * >(argp1);
13968 ecode2 = SWIG_AsVal_int(obj1, &val2);
13969 if (!SWIG_IsOK(ecode2)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13971 }
13972 arg2 = static_cast< int >(val2);
13973 {
13974 arg3 = wxString_in_helper(obj2);
13975 if (arg3 == NULL) SWIG_fail;
13976 temp3 = true;
13977 }
13978 {
13979 PyThreadState* __tstate = wxPyBeginAllowThreads();
13980 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_Py_Void();
13985 {
13986 if (temp3)
13987 delete arg3;
13988 }
13989 return resultobj;
13990 fail:
13991 {
13992 if (temp3)
13993 delete arg3;
13994 }
13995 return NULL;
13996 }
13997
13998
13999 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14000 PyObject *resultobj = 0;
14001 wxGrid *arg1 = (wxGrid *) 0 ;
14002 wxColour *arg2 = 0 ;
14003 void *argp1 = 0 ;
14004 int res1 = 0 ;
14005 wxColour temp2 ;
14006 PyObject * obj0 = 0 ;
14007 PyObject * obj1 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "self",(char *)"arg2", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14014 if (!SWIG_IsOK(res1)) {
14015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14016 }
14017 arg1 = reinterpret_cast< wxGrid * >(argp1);
14018 {
14019 arg2 = &temp2;
14020 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14021 }
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 resultobj = SWIG_Py_Void();
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj = 0;
14037 wxGrid *arg1 = (wxGrid *) 0 ;
14038 wxColour *arg2 = 0 ;
14039 void *argp1 = 0 ;
14040 int res1 = 0 ;
14041 wxColour temp2 ;
14042 PyObject * obj0 = 0 ;
14043 PyObject * obj1 = 0 ;
14044 char * kwnames[] = {
14045 (char *) "self",(char *)"arg2", NULL
14046 };
14047
14048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14050 if (!SWIG_IsOK(res1)) {
14051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14052 }
14053 arg1 = reinterpret_cast< wxGrid * >(argp1);
14054 {
14055 arg2 = &temp2;
14056 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14057 }
14058 {
14059 PyThreadState* __tstate = wxPyBeginAllowThreads();
14060 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14061 wxPyEndAllowThreads(__tstate);
14062 if (PyErr_Occurred()) SWIG_fail;
14063 }
14064 resultobj = SWIG_Py_Void();
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj = 0;
14073 wxGrid *arg1 = (wxGrid *) 0 ;
14074 int arg2 ;
14075 void *argp1 = 0 ;
14076 int res1 = 0 ;
14077 int val2 ;
14078 int ecode2 = 0 ;
14079 PyObject * obj0 = 0 ;
14080 PyObject * obj1 = 0 ;
14081 char * kwnames[] = {
14082 (char *) "self",(char *) "width", NULL
14083 };
14084
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14087 if (!SWIG_IsOK(res1)) {
14088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14089 }
14090 arg1 = reinterpret_cast< wxGrid * >(argp1);
14091 ecode2 = SWIG_AsVal_int(obj1, &val2);
14092 if (!SWIG_IsOK(ecode2)) {
14093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14094 }
14095 arg2 = static_cast< int >(val2);
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 (arg1)->SetCellHighlightPenWidth(arg2);
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 resultobj = SWIG_Py_Void();
14103 return resultobj;
14104 fail:
14105 return NULL;
14106 }
14107
14108
14109 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14110 PyObject *resultobj = 0;
14111 wxGrid *arg1 = (wxGrid *) 0 ;
14112 int arg2 ;
14113 void *argp1 = 0 ;
14114 int res1 = 0 ;
14115 int val2 ;
14116 int ecode2 = 0 ;
14117 PyObject * obj0 = 0 ;
14118 PyObject * obj1 = 0 ;
14119 char * kwnames[] = {
14120 (char *) "self",(char *) "width", NULL
14121 };
14122
14123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14125 if (!SWIG_IsOK(res1)) {
14126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14127 }
14128 arg1 = reinterpret_cast< wxGrid * >(argp1);
14129 ecode2 = SWIG_AsVal_int(obj1, &val2);
14130 if (!SWIG_IsOK(ecode2)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14132 }
14133 arg2 = static_cast< int >(val2);
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 (arg1)->SetCellHighlightROPenWidth(arg2);
14137 wxPyEndAllowThreads(__tstate);
14138 if (PyErr_Occurred()) SWIG_fail;
14139 }
14140 resultobj = SWIG_Py_Void();
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj = 0;
14149 wxGrid *arg1 = (wxGrid *) 0 ;
14150 bool arg2 = (bool) true ;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 bool val2 ;
14154 int ecode2 = 0 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 char * kwnames[] = {
14158 (char *) "self",(char *) "enable", NULL
14159 };
14160
14161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14163 if (!SWIG_IsOK(res1)) {
14164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14165 }
14166 arg1 = reinterpret_cast< wxGrid * >(argp1);
14167 if (obj1) {
14168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14169 if (!SWIG_IsOK(ecode2)) {
14170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14171 }
14172 arg2 = static_cast< bool >(val2);
14173 }
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 (arg1)->EnableDragRowSize(arg2);
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 resultobj = SWIG_Py_Void();
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *resultobj = 0;
14189 wxGrid *arg1 = (wxGrid *) 0 ;
14190 void *argp1 = 0 ;
14191 int res1 = 0 ;
14192 PyObject *swig_obj[1] ;
14193
14194 if (!args) SWIG_fail;
14195 swig_obj[0] = args;
14196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14197 if (!SWIG_IsOK(res1)) {
14198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14199 }
14200 arg1 = reinterpret_cast< wxGrid * >(argp1);
14201 {
14202 PyThreadState* __tstate = wxPyBeginAllowThreads();
14203 (arg1)->DisableDragRowSize();
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 resultobj = SWIG_Py_Void();
14208 return resultobj;
14209 fail:
14210 return NULL;
14211 }
14212
14213
14214 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14215 PyObject *resultobj = 0;
14216 wxGrid *arg1 = (wxGrid *) 0 ;
14217 bool result;
14218 void *argp1 = 0 ;
14219 int res1 = 0 ;
14220 PyObject *swig_obj[1] ;
14221
14222 if (!args) SWIG_fail;
14223 swig_obj[0] = args;
14224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14225 if (!SWIG_IsOK(res1)) {
14226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14227 }
14228 arg1 = reinterpret_cast< wxGrid * >(argp1);
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 result = (bool)(arg1)->CanDragRowSize();
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 {
14236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj = 0;
14246 wxGrid *arg1 = (wxGrid *) 0 ;
14247 bool arg2 = (bool) true ;
14248 void *argp1 = 0 ;
14249 int res1 = 0 ;
14250 bool val2 ;
14251 int ecode2 = 0 ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char * kwnames[] = {
14255 (char *) "self",(char *) "enable", NULL
14256 };
14257
14258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14260 if (!SWIG_IsOK(res1)) {
14261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14262 }
14263 arg1 = reinterpret_cast< wxGrid * >(argp1);
14264 if (obj1) {
14265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14266 if (!SWIG_IsOK(ecode2)) {
14267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14268 }
14269 arg2 = static_cast< bool >(val2);
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->EnableDragColSize(arg2);
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 resultobj = SWIG_Py_Void();
14278 return resultobj;
14279 fail:
14280 return NULL;
14281 }
14282
14283
14284 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14285 PyObject *resultobj = 0;
14286 wxGrid *arg1 = (wxGrid *) 0 ;
14287 void *argp1 = 0 ;
14288 int res1 = 0 ;
14289 PyObject *swig_obj[1] ;
14290
14291 if (!args) SWIG_fail;
14292 swig_obj[0] = args;
14293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14294 if (!SWIG_IsOK(res1)) {
14295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14296 }
14297 arg1 = reinterpret_cast< wxGrid * >(argp1);
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 (arg1)->DisableDragColSize();
14301 wxPyEndAllowThreads(__tstate);
14302 if (PyErr_Occurred()) SWIG_fail;
14303 }
14304 resultobj = SWIG_Py_Void();
14305 return resultobj;
14306 fail:
14307 return NULL;
14308 }
14309
14310
14311 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14312 PyObject *resultobj = 0;
14313 wxGrid *arg1 = (wxGrid *) 0 ;
14314 bool result;
14315 void *argp1 = 0 ;
14316 int res1 = 0 ;
14317 PyObject *swig_obj[1] ;
14318
14319 if (!args) SWIG_fail;
14320 swig_obj[0] = args;
14321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14322 if (!SWIG_IsOK(res1)) {
14323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14324 }
14325 arg1 = reinterpret_cast< wxGrid * >(argp1);
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (bool)(arg1)->CanDragColSize();
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = 0;
14343 wxGrid *arg1 = (wxGrid *) 0 ;
14344 bool arg2 = (bool) true ;
14345 void *argp1 = 0 ;
14346 int res1 = 0 ;
14347 bool val2 ;
14348 int ecode2 = 0 ;
14349 PyObject * obj0 = 0 ;
14350 PyObject * obj1 = 0 ;
14351 char * kwnames[] = {
14352 (char *) "self",(char *) "enable", NULL
14353 };
14354
14355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14357 if (!SWIG_IsOK(res1)) {
14358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14359 }
14360 arg1 = reinterpret_cast< wxGrid * >(argp1);
14361 if (obj1) {
14362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14363 if (!SWIG_IsOK(ecode2)) {
14364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14365 }
14366 arg2 = static_cast< bool >(val2);
14367 }
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 (arg1)->EnableDragColMove(arg2);
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 resultobj = SWIG_Py_Void();
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 PyObject *resultobj = 0;
14383 wxGrid *arg1 = (wxGrid *) 0 ;
14384 void *argp1 = 0 ;
14385 int res1 = 0 ;
14386 PyObject *swig_obj[1] ;
14387
14388 if (!args) SWIG_fail;
14389 swig_obj[0] = args;
14390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14391 if (!SWIG_IsOK(res1)) {
14392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14393 }
14394 arg1 = reinterpret_cast< wxGrid * >(argp1);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 (arg1)->DisableDragColMove();
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 resultobj = SWIG_Py_Void();
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14409 PyObject *resultobj = 0;
14410 wxGrid *arg1 = (wxGrid *) 0 ;
14411 bool result;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 PyObject *swig_obj[1] ;
14415
14416 if (!args) SWIG_fail;
14417 swig_obj[0] = args;
14418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14419 if (!SWIG_IsOK(res1)) {
14420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14421 }
14422 arg1 = reinterpret_cast< wxGrid * >(argp1);
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 result = (bool)(arg1)->CanDragColMove();
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 {
14430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14431 }
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14439 PyObject *resultobj = 0;
14440 wxGrid *arg1 = (wxGrid *) 0 ;
14441 bool arg2 = (bool) true ;
14442 void *argp1 = 0 ;
14443 int res1 = 0 ;
14444 bool val2 ;
14445 int ecode2 = 0 ;
14446 PyObject * obj0 = 0 ;
14447 PyObject * obj1 = 0 ;
14448 char * kwnames[] = {
14449 (char *) "self",(char *) "enable", NULL
14450 };
14451
14452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14454 if (!SWIG_IsOK(res1)) {
14455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14456 }
14457 arg1 = reinterpret_cast< wxGrid * >(argp1);
14458 if (obj1) {
14459 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14460 if (!SWIG_IsOK(ecode2)) {
14461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14462 }
14463 arg2 = static_cast< bool >(val2);
14464 }
14465 {
14466 PyThreadState* __tstate = wxPyBeginAllowThreads();
14467 (arg1)->EnableDragGridSize(arg2);
14468 wxPyEndAllowThreads(__tstate);
14469 if (PyErr_Occurred()) SWIG_fail;
14470 }
14471 resultobj = SWIG_Py_Void();
14472 return resultobj;
14473 fail:
14474 return NULL;
14475 }
14476
14477
14478 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14479 PyObject *resultobj = 0;
14480 wxGrid *arg1 = (wxGrid *) 0 ;
14481 void *argp1 = 0 ;
14482 int res1 = 0 ;
14483 PyObject *swig_obj[1] ;
14484
14485 if (!args) SWIG_fail;
14486 swig_obj[0] = args;
14487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14488 if (!SWIG_IsOK(res1)) {
14489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14490 }
14491 arg1 = reinterpret_cast< wxGrid * >(argp1);
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 (arg1)->DisableDragGridSize();
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 resultobj = SWIG_Py_Void();
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14506 PyObject *resultobj = 0;
14507 wxGrid *arg1 = (wxGrid *) 0 ;
14508 bool result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 PyObject *swig_obj[1] ;
14512
14513 if (!args) SWIG_fail;
14514 swig_obj[0] = args;
14515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14516 if (!SWIG_IsOK(res1)) {
14517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14518 }
14519 arg1 = reinterpret_cast< wxGrid * >(argp1);
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 result = (bool)(arg1)->CanDragGridSize();
14523 wxPyEndAllowThreads(__tstate);
14524 if (PyErr_Occurred()) SWIG_fail;
14525 }
14526 {
14527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14528 }
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj = 0;
14537 wxGrid *arg1 = (wxGrid *) 0 ;
14538 bool arg2 = (bool) true ;
14539 void *argp1 = 0 ;
14540 int res1 = 0 ;
14541 bool val2 ;
14542 int ecode2 = 0 ;
14543 PyObject * obj0 = 0 ;
14544 PyObject * obj1 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "enable", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14553 }
14554 arg1 = reinterpret_cast< wxGrid * >(argp1);
14555 if (obj1) {
14556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14557 if (!SWIG_IsOK(ecode2)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14559 }
14560 arg2 = static_cast< bool >(val2);
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->EnableDragCell(arg2);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576 PyObject *resultobj = 0;
14577 wxGrid *arg1 = (wxGrid *) 0 ;
14578 void *argp1 = 0 ;
14579 int res1 = 0 ;
14580 PyObject *swig_obj[1] ;
14581
14582 if (!args) SWIG_fail;
14583 swig_obj[0] = args;
14584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14585 if (!SWIG_IsOK(res1)) {
14586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14587 }
14588 arg1 = reinterpret_cast< wxGrid * >(argp1);
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->DisableDragCell();
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_Py_Void();
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14603 PyObject *resultobj = 0;
14604 wxGrid *arg1 = (wxGrid *) 0 ;
14605 bool result;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 PyObject *swig_obj[1] ;
14609
14610 if (!args) SWIG_fail;
14611 swig_obj[0] = args;
14612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14613 if (!SWIG_IsOK(res1)) {
14614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14615 }
14616 arg1 = reinterpret_cast< wxGrid * >(argp1);
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->CanDragCell();
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxGrid *arg1 = (wxGrid *) 0 ;
14635 int arg2 ;
14636 int arg3 ;
14637 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14638 void *argp1 = 0 ;
14639 int res1 = 0 ;
14640 int val2 ;
14641 int ecode2 = 0 ;
14642 int val3 ;
14643 int ecode3 = 0 ;
14644 void *argp4 = 0 ;
14645 int res4 = 0 ;
14646 PyObject * obj0 = 0 ;
14647 PyObject * obj1 = 0 ;
14648 PyObject * obj2 = 0 ;
14649 PyObject * obj3 = 0 ;
14650 char * kwnames[] = {
14651 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14652 };
14653
14654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14656 if (!SWIG_IsOK(res1)) {
14657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14658 }
14659 arg1 = reinterpret_cast< wxGrid * >(argp1);
14660 ecode2 = SWIG_AsVal_int(obj1, &val2);
14661 if (!SWIG_IsOK(ecode2)) {
14662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14663 }
14664 arg2 = static_cast< int >(val2);
14665 ecode3 = SWIG_AsVal_int(obj2, &val3);
14666 if (!SWIG_IsOK(ecode3)) {
14667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14668 }
14669 arg3 = static_cast< int >(val3);
14670 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14671 if (!SWIG_IsOK(res4)) {
14672 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14673 }
14674 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 (arg1)->SetAttr(arg2,arg3,arg4);
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 resultobj = SWIG_Py_Void();
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj = 0;
14690 wxGrid *arg1 = (wxGrid *) 0 ;
14691 int arg2 ;
14692 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 int val2 ;
14696 int ecode2 = 0 ;
14697 void *argp3 = 0 ;
14698 int res3 = 0 ;
14699 PyObject * obj0 = 0 ;
14700 PyObject * obj1 = 0 ;
14701 PyObject * obj2 = 0 ;
14702 char * kwnames[] = {
14703 (char *) "self",(char *) "row",(char *) "attr", NULL
14704 };
14705
14706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14708 if (!SWIG_IsOK(res1)) {
14709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14710 }
14711 arg1 = reinterpret_cast< wxGrid * >(argp1);
14712 ecode2 = SWIG_AsVal_int(obj1, &val2);
14713 if (!SWIG_IsOK(ecode2)) {
14714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14715 }
14716 arg2 = static_cast< int >(val2);
14717 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14718 if (!SWIG_IsOK(res3)) {
14719 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14720 }
14721 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 (arg1)->SetRowAttr(arg2,arg3);
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_Py_Void();
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 wxGrid *arg1 = (wxGrid *) 0 ;
14738 int arg2 ;
14739 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14740 void *argp1 = 0 ;
14741 int res1 = 0 ;
14742 int val2 ;
14743 int ecode2 = 0 ;
14744 void *argp3 = 0 ;
14745 int res3 = 0 ;
14746 PyObject * obj0 = 0 ;
14747 PyObject * obj1 = 0 ;
14748 PyObject * obj2 = 0 ;
14749 char * kwnames[] = {
14750 (char *) "self",(char *) "col",(char *) "attr", NULL
14751 };
14752
14753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14755 if (!SWIG_IsOK(res1)) {
14756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14757 }
14758 arg1 = reinterpret_cast< wxGrid * >(argp1);
14759 ecode2 = SWIG_AsVal_int(obj1, &val2);
14760 if (!SWIG_IsOK(ecode2)) {
14761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14762 }
14763 arg2 = static_cast< int >(val2);
14764 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14765 if (!SWIG_IsOK(res3)) {
14766 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14767 }
14768 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 (arg1)->SetColAttr(arg2,arg3);
14772 wxPyEndAllowThreads(__tstate);
14773 if (PyErr_Occurred()) SWIG_fail;
14774 }
14775 resultobj = SWIG_Py_Void();
14776 return resultobj;
14777 fail:
14778 return NULL;
14779 }
14780
14781
14782 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14783 PyObject *resultobj = 0;
14784 wxGrid *arg1 = (wxGrid *) 0 ;
14785 int arg2 ;
14786 int arg3 ;
14787 wxGridCellAttr *result = 0 ;
14788 void *argp1 = 0 ;
14789 int res1 = 0 ;
14790 int val2 ;
14791 int ecode2 = 0 ;
14792 int val3 ;
14793 int ecode3 = 0 ;
14794 PyObject * obj0 = 0 ;
14795 PyObject * obj1 = 0 ;
14796 PyObject * obj2 = 0 ;
14797 char * kwnames[] = {
14798 (char *) "self",(char *) "row",(char *) "col", NULL
14799 };
14800
14801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14803 if (!SWIG_IsOK(res1)) {
14804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14805 }
14806 arg1 = reinterpret_cast< wxGrid * >(argp1);
14807 ecode2 = SWIG_AsVal_int(obj1, &val2);
14808 if (!SWIG_IsOK(ecode2)) {
14809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14810 }
14811 arg2 = static_cast< int >(val2);
14812 ecode3 = SWIG_AsVal_int(obj2, &val3);
14813 if (!SWIG_IsOK(ecode3)) {
14814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14815 }
14816 arg3 = static_cast< int >(val3);
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14820 wxPyEndAllowThreads(__tstate);
14821 if (PyErr_Occurred()) SWIG_fail;
14822 }
14823 {
14824 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14825 }
14826 return resultobj;
14827 fail:
14828 return NULL;
14829 }
14830
14831
14832 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14833 PyObject *resultobj = 0;
14834 wxGrid *arg1 = (wxGrid *) 0 ;
14835 int arg2 ;
14836 void *argp1 = 0 ;
14837 int res1 = 0 ;
14838 int val2 ;
14839 int ecode2 = 0 ;
14840 PyObject * obj0 = 0 ;
14841 PyObject * obj1 = 0 ;
14842 char * kwnames[] = {
14843 (char *) "self",(char *) "col", NULL
14844 };
14845
14846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14848 if (!SWIG_IsOK(res1)) {
14849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14850 }
14851 arg1 = reinterpret_cast< wxGrid * >(argp1);
14852 ecode2 = SWIG_AsVal_int(obj1, &val2);
14853 if (!SWIG_IsOK(ecode2)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14855 }
14856 arg2 = static_cast< int >(val2);
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 (arg1)->SetColFormatBool(arg2);
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_Py_Void();
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj = 0;
14872 wxGrid *arg1 = (wxGrid *) 0 ;
14873 int arg2 ;
14874 void *argp1 = 0 ;
14875 int res1 = 0 ;
14876 int val2 ;
14877 int ecode2 = 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 char * kwnames[] = {
14881 (char *) "self",(char *) "col", NULL
14882 };
14883
14884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14886 if (!SWIG_IsOK(res1)) {
14887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14888 }
14889 arg1 = reinterpret_cast< wxGrid * >(argp1);
14890 ecode2 = SWIG_AsVal_int(obj1, &val2);
14891 if (!SWIG_IsOK(ecode2)) {
14892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14893 }
14894 arg2 = static_cast< int >(val2);
14895 {
14896 PyThreadState* __tstate = wxPyBeginAllowThreads();
14897 (arg1)->SetColFormatNumber(arg2);
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 resultobj = SWIG_Py_Void();
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj = 0;
14910 wxGrid *arg1 = (wxGrid *) 0 ;
14911 int arg2 ;
14912 int arg3 = (int) -1 ;
14913 int arg4 = (int) -1 ;
14914 void *argp1 = 0 ;
14915 int res1 = 0 ;
14916 int val2 ;
14917 int ecode2 = 0 ;
14918 int val3 ;
14919 int ecode3 = 0 ;
14920 int val4 ;
14921 int ecode4 = 0 ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 PyObject * obj2 = 0 ;
14925 PyObject * obj3 = 0 ;
14926 char * kwnames[] = {
14927 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14928 };
14929
14930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14932 if (!SWIG_IsOK(res1)) {
14933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14934 }
14935 arg1 = reinterpret_cast< wxGrid * >(argp1);
14936 ecode2 = SWIG_AsVal_int(obj1, &val2);
14937 if (!SWIG_IsOK(ecode2)) {
14938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14939 }
14940 arg2 = static_cast< int >(val2);
14941 if (obj2) {
14942 ecode3 = SWIG_AsVal_int(obj2, &val3);
14943 if (!SWIG_IsOK(ecode3)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14945 }
14946 arg3 = static_cast< int >(val3);
14947 }
14948 if (obj3) {
14949 ecode4 = SWIG_AsVal_int(obj3, &val4);
14950 if (!SWIG_IsOK(ecode4)) {
14951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14952 }
14953 arg4 = static_cast< int >(val4);
14954 }
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 resultobj = SWIG_Py_Void();
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14969 PyObject *resultobj = 0;
14970 wxGrid *arg1 = (wxGrid *) 0 ;
14971 int arg2 ;
14972 wxString *arg3 = 0 ;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 int val2 ;
14976 int ecode2 = 0 ;
14977 bool temp3 = false ;
14978 PyObject * obj0 = 0 ;
14979 PyObject * obj1 = 0 ;
14980 PyObject * obj2 = 0 ;
14981 char * kwnames[] = {
14982 (char *) "self",(char *) "col",(char *) "typeName", NULL
14983 };
14984
14985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14987 if (!SWIG_IsOK(res1)) {
14988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14989 }
14990 arg1 = reinterpret_cast< wxGrid * >(argp1);
14991 ecode2 = SWIG_AsVal_int(obj1, &val2);
14992 if (!SWIG_IsOK(ecode2)) {
14993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14994 }
14995 arg2 = static_cast< int >(val2);
14996 {
14997 arg3 = wxString_in_helper(obj2);
14998 if (arg3 == NULL) SWIG_fail;
14999 temp3 = true;
15000 }
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 resultobj = SWIG_Py_Void();
15008 {
15009 if (temp3)
15010 delete arg3;
15011 }
15012 return resultobj;
15013 fail:
15014 {
15015 if (temp3)
15016 delete arg3;
15017 }
15018 return NULL;
15019 }
15020
15021
15022 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj = 0;
15024 wxGrid *arg1 = (wxGrid *) 0 ;
15025 bool arg2 = (bool) true ;
15026 void *argp1 = 0 ;
15027 int res1 = 0 ;
15028 bool val2 ;
15029 int ecode2 = 0 ;
15030 PyObject * obj0 = 0 ;
15031 PyObject * obj1 = 0 ;
15032 char * kwnames[] = {
15033 (char *) "self",(char *) "enable", NULL
15034 };
15035
15036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15038 if (!SWIG_IsOK(res1)) {
15039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15040 }
15041 arg1 = reinterpret_cast< wxGrid * >(argp1);
15042 if (obj1) {
15043 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15044 if (!SWIG_IsOK(ecode2)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15046 }
15047 arg2 = static_cast< bool >(val2);
15048 }
15049 {
15050 PyThreadState* __tstate = wxPyBeginAllowThreads();
15051 (arg1)->EnableGridLines(arg2);
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 resultobj = SWIG_Py_Void();
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15063 PyObject *resultobj = 0;
15064 wxGrid *arg1 = (wxGrid *) 0 ;
15065 bool result;
15066 void *argp1 = 0 ;
15067 int res1 = 0 ;
15068 PyObject *swig_obj[1] ;
15069
15070 if (!args) SWIG_fail;
15071 swig_obj[0] = args;
15072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15073 if (!SWIG_IsOK(res1)) {
15074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15075 }
15076 arg1 = reinterpret_cast< wxGrid * >(argp1);
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = (bool)(arg1)->GridLinesEnabled();
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 {
15084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15085 }
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15093 PyObject *resultobj = 0;
15094 wxGrid *arg1 = (wxGrid *) 0 ;
15095 int result;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 PyObject *swig_obj[1] ;
15099
15100 if (!args) SWIG_fail;
15101 swig_obj[0] = args;
15102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15105 }
15106 arg1 = reinterpret_cast< wxGrid * >(argp1);
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 result = (int)(arg1)->GetDefaultRowSize();
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 resultobj = SWIG_From_int(static_cast< int >(result));
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj = 0;
15122 wxGrid *arg1 = (wxGrid *) 0 ;
15123 int arg2 ;
15124 int result;
15125 void *argp1 = 0 ;
15126 int res1 = 0 ;
15127 int val2 ;
15128 int ecode2 = 0 ;
15129 PyObject * obj0 = 0 ;
15130 PyObject * obj1 = 0 ;
15131 char * kwnames[] = {
15132 (char *) "self",(char *) "row", NULL
15133 };
15134
15135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15139 }
15140 arg1 = reinterpret_cast< wxGrid * >(argp1);
15141 ecode2 = SWIG_AsVal_int(obj1, &val2);
15142 if (!SWIG_IsOK(ecode2)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15144 }
15145 arg2 = static_cast< int >(val2);
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (int)(arg1)->GetRowSize(arg2);
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 resultobj = SWIG_From_int(static_cast< int >(result));
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxGrid *arg1 = (wxGrid *) 0 ;
15162 int result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15172 }
15173 arg1 = reinterpret_cast< wxGrid * >(argp1);
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (int)(arg1)->GetDefaultColSize();
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_From_int(static_cast< int >(result));
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15188 PyObject *resultobj = 0;
15189 wxGrid *arg1 = (wxGrid *) 0 ;
15190 int arg2 ;
15191 int result;
15192 void *argp1 = 0 ;
15193 int res1 = 0 ;
15194 int val2 ;
15195 int ecode2 = 0 ;
15196 PyObject * obj0 = 0 ;
15197 PyObject * obj1 = 0 ;
15198 char * kwnames[] = {
15199 (char *) "self",(char *) "col", NULL
15200 };
15201
15202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15206 }
15207 arg1 = reinterpret_cast< wxGrid * >(argp1);
15208 ecode2 = SWIG_AsVal_int(obj1, &val2);
15209 if (!SWIG_IsOK(ecode2)) {
15210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15211 }
15212 arg2 = static_cast< int >(val2);
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (int)(arg1)->GetColSize(arg2);
15216 wxPyEndAllowThreads(__tstate);
15217 if (PyErr_Occurred()) SWIG_fail;
15218 }
15219 resultobj = SWIG_From_int(static_cast< int >(result));
15220 return resultobj;
15221 fail:
15222 return NULL;
15223 }
15224
15225
15226 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15227 PyObject *resultobj = 0;
15228 wxGrid *arg1 = (wxGrid *) 0 ;
15229 wxColour result;
15230 void *argp1 = 0 ;
15231 int res1 = 0 ;
15232 PyObject *swig_obj[1] ;
15233
15234 if (!args) SWIG_fail;
15235 swig_obj[0] = args;
15236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15239 }
15240 arg1 = reinterpret_cast< wxGrid * >(argp1);
15241 {
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 result = (arg1)->GetDefaultCellBackgroundColour();
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15255 PyObject *resultobj = 0;
15256 wxGrid *arg1 = (wxGrid *) 0 ;
15257 int arg2 ;
15258 int arg3 ;
15259 wxColour result;
15260 void *argp1 = 0 ;
15261 int res1 = 0 ;
15262 int val2 ;
15263 int ecode2 = 0 ;
15264 int val3 ;
15265 int ecode3 = 0 ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 PyObject * obj2 = 0 ;
15269 char * kwnames[] = {
15270 (char *) "self",(char *) "row",(char *) "col", NULL
15271 };
15272
15273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15275 if (!SWIG_IsOK(res1)) {
15276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15277 }
15278 arg1 = reinterpret_cast< wxGrid * >(argp1);
15279 ecode2 = SWIG_AsVal_int(obj1, &val2);
15280 if (!SWIG_IsOK(ecode2)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15282 }
15283 arg2 = static_cast< int >(val2);
15284 ecode3 = SWIG_AsVal_int(obj2, &val3);
15285 if (!SWIG_IsOK(ecode3)) {
15286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15287 }
15288 arg3 = static_cast< int >(val3);
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15303 PyObject *resultobj = 0;
15304 wxGrid *arg1 = (wxGrid *) 0 ;
15305 wxColour result;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject *swig_obj[1] ;
15309
15310 if (!args) SWIG_fail;
15311 swig_obj[0] = args;
15312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15315 }
15316 arg1 = reinterpret_cast< wxGrid * >(argp1);
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (arg1)->GetDefaultCellTextColour();
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj = 0;
15332 wxGrid *arg1 = (wxGrid *) 0 ;
15333 int arg2 ;
15334 int arg3 ;
15335 wxColour result;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 int val2 ;
15339 int ecode2 = 0 ;
15340 int val3 ;
15341 int ecode3 = 0 ;
15342 PyObject * obj0 = 0 ;
15343 PyObject * obj1 = 0 ;
15344 PyObject * obj2 = 0 ;
15345 char * kwnames[] = {
15346 (char *) "self",(char *) "row",(char *) "col", NULL
15347 };
15348
15349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15351 if (!SWIG_IsOK(res1)) {
15352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15353 }
15354 arg1 = reinterpret_cast< wxGrid * >(argp1);
15355 ecode2 = SWIG_AsVal_int(obj1, &val2);
15356 if (!SWIG_IsOK(ecode2)) {
15357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15358 }
15359 arg2 = static_cast< int >(val2);
15360 ecode3 = SWIG_AsVal_int(obj2, &val3);
15361 if (!SWIG_IsOK(ecode3)) {
15362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15363 }
15364 arg3 = static_cast< int >(val3);
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (arg1)->GetCellTextColour(arg2,arg3);
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15379 PyObject *resultobj = 0;
15380 wxGrid *arg1 = (wxGrid *) 0 ;
15381 wxFont result;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject *swig_obj[1] ;
15385
15386 if (!args) SWIG_fail;
15387 swig_obj[0] = args;
15388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15391 }
15392 arg1 = reinterpret_cast< wxGrid * >(argp1);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 result = (arg1)->GetDefaultCellFont();
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj = 0;
15408 wxGrid *arg1 = (wxGrid *) 0 ;
15409 int arg2 ;
15410 int arg3 ;
15411 wxFont result;
15412 void *argp1 = 0 ;
15413 int res1 = 0 ;
15414 int val2 ;
15415 int ecode2 = 0 ;
15416 int val3 ;
15417 int ecode3 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 PyObject * obj2 = 0 ;
15421 char * kwnames[] = {
15422 (char *) "self",(char *) "row",(char *) "col", NULL
15423 };
15424
15425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15429 }
15430 arg1 = reinterpret_cast< wxGrid * >(argp1);
15431 ecode2 = SWIG_AsVal_int(obj1, &val2);
15432 if (!SWIG_IsOK(ecode2)) {
15433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15434 }
15435 arg2 = static_cast< int >(val2);
15436 ecode3 = SWIG_AsVal_int(obj2, &val3);
15437 if (!SWIG_IsOK(ecode3)) {
15438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15439 }
15440 arg3 = static_cast< int >(val3);
15441 {
15442 PyThreadState* __tstate = wxPyBeginAllowThreads();
15443 result = (arg1)->GetCellFont(arg2,arg3);
15444 wxPyEndAllowThreads(__tstate);
15445 if (PyErr_Occurred()) SWIG_fail;
15446 }
15447 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15448 return resultobj;
15449 fail:
15450 return NULL;
15451 }
15452
15453
15454 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15455 PyObject *resultobj = 0;
15456 wxGrid *arg1 = (wxGrid *) 0 ;
15457 int *arg2 = (int *) 0 ;
15458 int *arg3 = (int *) 0 ;
15459 void *argp1 = 0 ;
15460 int res1 = 0 ;
15461 int temp2 ;
15462 int res2 = SWIG_TMPOBJ ;
15463 int temp3 ;
15464 int res3 = SWIG_TMPOBJ ;
15465 PyObject *swig_obj[1] ;
15466
15467 arg2 = &temp2;
15468 arg3 = &temp3;
15469 if (!args) SWIG_fail;
15470 swig_obj[0] = args;
15471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15472 if (!SWIG_IsOK(res1)) {
15473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15474 }
15475 arg1 = reinterpret_cast< wxGrid * >(argp1);
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 resultobj = SWIG_Py_Void();
15483 if (SWIG_IsTmpObj(res2)) {
15484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15485 } else {
15486 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15488 }
15489 if (SWIG_IsTmpObj(res3)) {
15490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15491 } else {
15492 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15494 }
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj = 0;
15503 wxGrid *arg1 = (wxGrid *) 0 ;
15504 int arg2 ;
15505 int arg3 ;
15506 int *arg4 = (int *) 0 ;
15507 int *arg5 = (int *) 0 ;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 int val2 ;
15511 int ecode2 = 0 ;
15512 int val3 ;
15513 int ecode3 = 0 ;
15514 int temp4 ;
15515 int res4 = SWIG_TMPOBJ ;
15516 int temp5 ;
15517 int res5 = SWIG_TMPOBJ ;
15518 PyObject * obj0 = 0 ;
15519 PyObject * obj1 = 0 ;
15520 PyObject * obj2 = 0 ;
15521 char * kwnames[] = {
15522 (char *) "self",(char *) "row",(char *) "col", NULL
15523 };
15524
15525 arg4 = &temp4;
15526 arg5 = &temp5;
15527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15529 if (!SWIG_IsOK(res1)) {
15530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15531 }
15532 arg1 = reinterpret_cast< wxGrid * >(argp1);
15533 ecode2 = SWIG_AsVal_int(obj1, &val2);
15534 if (!SWIG_IsOK(ecode2)) {
15535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15536 }
15537 arg2 = static_cast< int >(val2);
15538 ecode3 = SWIG_AsVal_int(obj2, &val3);
15539 if (!SWIG_IsOK(ecode3)) {
15540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15541 }
15542 arg3 = static_cast< int >(val3);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 resultobj = SWIG_Py_Void();
15550 if (SWIG_IsTmpObj(res4)) {
15551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15552 } else {
15553 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15555 }
15556 if (SWIG_IsTmpObj(res5)) {
15557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15558 } else {
15559 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15561 }
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15569 PyObject *resultobj = 0;
15570 wxGrid *arg1 = (wxGrid *) 0 ;
15571 bool result;
15572 void *argp1 = 0 ;
15573 int res1 = 0 ;
15574 PyObject *swig_obj[1] ;
15575
15576 if (!args) SWIG_fail;
15577 swig_obj[0] = args;
15578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15579 if (!SWIG_IsOK(res1)) {
15580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15581 }
15582 arg1 = reinterpret_cast< wxGrid * >(argp1);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 result = (bool)(arg1)->GetDefaultCellOverflow();
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 {
15590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15591 }
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj = 0;
15600 wxGrid *arg1 = (wxGrid *) 0 ;
15601 int arg2 ;
15602 int arg3 ;
15603 bool result;
15604 void *argp1 = 0 ;
15605 int res1 = 0 ;
15606 int val2 ;
15607 int ecode2 = 0 ;
15608 int val3 ;
15609 int ecode3 = 0 ;
15610 PyObject * obj0 = 0 ;
15611 PyObject * obj1 = 0 ;
15612 PyObject * obj2 = 0 ;
15613 char * kwnames[] = {
15614 (char *) "self",(char *) "row",(char *) "col", NULL
15615 };
15616
15617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15619 if (!SWIG_IsOK(res1)) {
15620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15621 }
15622 arg1 = reinterpret_cast< wxGrid * >(argp1);
15623 ecode2 = SWIG_AsVal_int(obj1, &val2);
15624 if (!SWIG_IsOK(ecode2)) {
15625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15626 }
15627 arg2 = static_cast< int >(val2);
15628 ecode3 = SWIG_AsVal_int(obj2, &val3);
15629 if (!SWIG_IsOK(ecode3)) {
15630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15631 }
15632 arg3 = static_cast< int >(val3);
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15649 PyObject *resultobj = 0;
15650 wxGrid *arg1 = (wxGrid *) 0 ;
15651 int arg2 ;
15652 int arg3 ;
15653 int *arg4 = (int *) 0 ;
15654 int *arg5 = (int *) 0 ;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 int val2 ;
15658 int ecode2 = 0 ;
15659 int val3 ;
15660 int ecode3 = 0 ;
15661 int temp4 ;
15662 int res4 = SWIG_TMPOBJ ;
15663 int temp5 ;
15664 int res5 = SWIG_TMPOBJ ;
15665 PyObject * obj0 = 0 ;
15666 PyObject * obj1 = 0 ;
15667 PyObject * obj2 = 0 ;
15668 char * kwnames[] = {
15669 (char *) "self",(char *) "row",(char *) "col", NULL
15670 };
15671
15672 arg4 = &temp4;
15673 arg5 = &temp5;
15674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15678 }
15679 arg1 = reinterpret_cast< wxGrid * >(argp1);
15680 ecode2 = SWIG_AsVal_int(obj1, &val2);
15681 if (!SWIG_IsOK(ecode2)) {
15682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15683 }
15684 arg2 = static_cast< int >(val2);
15685 ecode3 = SWIG_AsVal_int(obj2, &val3);
15686 if (!SWIG_IsOK(ecode3)) {
15687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15688 }
15689 arg3 = static_cast< int >(val3);
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_Py_Void();
15697 if (SWIG_IsTmpObj(res4)) {
15698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15699 } else {
15700 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15702 }
15703 if (SWIG_IsTmpObj(res5)) {
15704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15705 } else {
15706 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15708 }
15709 return resultobj;
15710 fail:
15711 return NULL;
15712 }
15713
15714
15715 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15716 PyObject *resultobj = 0;
15717 wxGrid *arg1 = (wxGrid *) 0 ;
15718 int arg2 ;
15719 bool arg3 = (bool) false ;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 int val2 ;
15723 int ecode2 = 0 ;
15724 bool val3 ;
15725 int ecode3 = 0 ;
15726 PyObject * obj0 = 0 ;
15727 PyObject * obj1 = 0 ;
15728 PyObject * obj2 = 0 ;
15729 char * kwnames[] = {
15730 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15731 };
15732
15733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15735 if (!SWIG_IsOK(res1)) {
15736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15737 }
15738 arg1 = reinterpret_cast< wxGrid * >(argp1);
15739 ecode2 = SWIG_AsVal_int(obj1, &val2);
15740 if (!SWIG_IsOK(ecode2)) {
15741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15742 }
15743 arg2 = static_cast< int >(val2);
15744 if (obj2) {
15745 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15746 if (!SWIG_IsOK(ecode3)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15748 }
15749 arg3 = static_cast< bool >(val3);
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 (arg1)->SetDefaultRowSize(arg2,arg3);
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 resultobj = SWIG_Py_Void();
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj = 0;
15766 wxGrid *arg1 = (wxGrid *) 0 ;
15767 int arg2 ;
15768 int arg3 ;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 int val2 ;
15772 int ecode2 = 0 ;
15773 int val3 ;
15774 int ecode3 = 0 ;
15775 PyObject * obj0 = 0 ;
15776 PyObject * obj1 = 0 ;
15777 PyObject * obj2 = 0 ;
15778 char * kwnames[] = {
15779 (char *) "self",(char *) "row",(char *) "height", NULL
15780 };
15781
15782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15786 }
15787 arg1 = reinterpret_cast< wxGrid * >(argp1);
15788 ecode2 = SWIG_AsVal_int(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15791 }
15792 arg2 = static_cast< int >(val2);
15793 ecode3 = SWIG_AsVal_int(obj2, &val3);
15794 if (!SWIG_IsOK(ecode3)) {
15795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15796 }
15797 arg3 = static_cast< int >(val3);
15798 {
15799 PyThreadState* __tstate = wxPyBeginAllowThreads();
15800 (arg1)->SetRowSize(arg2,arg3);
15801 wxPyEndAllowThreads(__tstate);
15802 if (PyErr_Occurred()) SWIG_fail;
15803 }
15804 resultobj = SWIG_Py_Void();
15805 return resultobj;
15806 fail:
15807 return NULL;
15808 }
15809
15810
15811 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15812 PyObject *resultobj = 0;
15813 wxGrid *arg1 = (wxGrid *) 0 ;
15814 int arg2 ;
15815 bool arg3 = (bool) false ;
15816 void *argp1 = 0 ;
15817 int res1 = 0 ;
15818 int val2 ;
15819 int ecode2 = 0 ;
15820 bool val3 ;
15821 int ecode3 = 0 ;
15822 PyObject * obj0 = 0 ;
15823 PyObject * obj1 = 0 ;
15824 PyObject * obj2 = 0 ;
15825 char * kwnames[] = {
15826 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15827 };
15828
15829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15833 }
15834 arg1 = reinterpret_cast< wxGrid * >(argp1);
15835 ecode2 = SWIG_AsVal_int(obj1, &val2);
15836 if (!SWIG_IsOK(ecode2)) {
15837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15838 }
15839 arg2 = static_cast< int >(val2);
15840 if (obj2) {
15841 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15842 if (!SWIG_IsOK(ecode3)) {
15843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15844 }
15845 arg3 = static_cast< bool >(val3);
15846 }
15847 {
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 (arg1)->SetDefaultColSize(arg2,arg3);
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = SWIG_Py_Void();
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15861 PyObject *resultobj = 0;
15862 wxGrid *arg1 = (wxGrid *) 0 ;
15863 int arg2 ;
15864 int arg3 ;
15865 void *argp1 = 0 ;
15866 int res1 = 0 ;
15867 int val2 ;
15868 int ecode2 = 0 ;
15869 int val3 ;
15870 int ecode3 = 0 ;
15871 PyObject * obj0 = 0 ;
15872 PyObject * obj1 = 0 ;
15873 PyObject * obj2 = 0 ;
15874 char * kwnames[] = {
15875 (char *) "self",(char *) "col",(char *) "width", NULL
15876 };
15877
15878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15882 }
15883 arg1 = reinterpret_cast< wxGrid * >(argp1);
15884 ecode2 = SWIG_AsVal_int(obj1, &val2);
15885 if (!SWIG_IsOK(ecode2)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15887 }
15888 arg2 = static_cast< int >(val2);
15889 ecode3 = SWIG_AsVal_int(obj2, &val3);
15890 if (!SWIG_IsOK(ecode3)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15892 }
15893 arg3 = static_cast< int >(val3);
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 (arg1)->SetColSize(arg2,arg3);
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 resultobj = SWIG_Py_Void();
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15908 PyObject *resultobj = 0;
15909 wxGrid *arg1 = (wxGrid *) 0 ;
15910 int arg2 ;
15911 int result;
15912 void *argp1 = 0 ;
15913 int res1 = 0 ;
15914 int val2 ;
15915 int ecode2 = 0 ;
15916 PyObject * obj0 = 0 ;
15917 PyObject * obj1 = 0 ;
15918 char * kwnames[] = {
15919 (char *) "self",(char *) "colPos", NULL
15920 };
15921
15922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15926 }
15927 arg1 = reinterpret_cast< wxGrid * >(argp1);
15928 ecode2 = SWIG_AsVal_int(obj1, &val2);
15929 if (!SWIG_IsOK(ecode2)) {
15930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15931 }
15932 arg2 = static_cast< int >(val2);
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 resultobj = SWIG_From_int(static_cast< int >(result));
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj = 0;
15948 wxGrid *arg1 = (wxGrid *) 0 ;
15949 int arg2 ;
15950 int arg3 ;
15951 void *argp1 = 0 ;
15952 int res1 = 0 ;
15953 int val2 ;
15954 int ecode2 = 0 ;
15955 int val3 ;
15956 int ecode3 = 0 ;
15957 PyObject * obj0 = 0 ;
15958 PyObject * obj1 = 0 ;
15959 PyObject * obj2 = 0 ;
15960 char * kwnames[] = {
15961 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15962 };
15963
15964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15966 if (!SWIG_IsOK(res1)) {
15967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15968 }
15969 arg1 = reinterpret_cast< wxGrid * >(argp1);
15970 ecode2 = SWIG_AsVal_int(obj1, &val2);
15971 if (!SWIG_IsOK(ecode2)) {
15972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15973 }
15974 arg2 = static_cast< int >(val2);
15975 ecode3 = SWIG_AsVal_int(obj2, &val3);
15976 if (!SWIG_IsOK(ecode3)) {
15977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15978 }
15979 arg3 = static_cast< int >(val3);
15980 {
15981 PyThreadState* __tstate = wxPyBeginAllowThreads();
15982 (arg1)->SetColPos(arg2,arg3);
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 resultobj = SWIG_Py_Void();
15987 return resultobj;
15988 fail:
15989 return NULL;
15990 }
15991
15992
15993 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15994 PyObject *resultobj = 0;
15995 wxGrid *arg1 = (wxGrid *) 0 ;
15996 int arg2 ;
15997 int result;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 int val2 ;
16001 int ecode2 = 0 ;
16002 PyObject * obj0 = 0 ;
16003 PyObject * obj1 = 0 ;
16004 char * kwnames[] = {
16005 (char *) "self",(char *) "colID", NULL
16006 };
16007
16008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16010 if (!SWIG_IsOK(res1)) {
16011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16012 }
16013 arg1 = reinterpret_cast< wxGrid * >(argp1);
16014 ecode2 = SWIG_AsVal_int(obj1, &val2);
16015 if (!SWIG_IsOK(ecode2)) {
16016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16017 }
16018 arg2 = static_cast< int >(val2);
16019 {
16020 PyThreadState* __tstate = wxPyBeginAllowThreads();
16021 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 resultobj = SWIG_From_int(static_cast< int >(result));
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16033 PyObject *resultobj = 0;
16034 wxGrid *arg1 = (wxGrid *) 0 ;
16035 int arg2 ;
16036 bool arg3 = (bool) true ;
16037 void *argp1 = 0 ;
16038 int res1 = 0 ;
16039 int val2 ;
16040 int ecode2 = 0 ;
16041 bool val3 ;
16042 int ecode3 = 0 ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 PyObject * obj2 = 0 ;
16046 char * kwnames[] = {
16047 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16048 };
16049
16050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16052 if (!SWIG_IsOK(res1)) {
16053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16054 }
16055 arg1 = reinterpret_cast< wxGrid * >(argp1);
16056 ecode2 = SWIG_AsVal_int(obj1, &val2);
16057 if (!SWIG_IsOK(ecode2)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16059 }
16060 arg2 = static_cast< int >(val2);
16061 if (obj2) {
16062 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16063 if (!SWIG_IsOK(ecode3)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16065 }
16066 arg3 = static_cast< bool >(val3);
16067 }
16068 {
16069 PyThreadState* __tstate = wxPyBeginAllowThreads();
16070 (arg1)->AutoSizeColumn(arg2,arg3);
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 resultobj = SWIG_Py_Void();
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16082 PyObject *resultobj = 0;
16083 wxGrid *arg1 = (wxGrid *) 0 ;
16084 int arg2 ;
16085 bool arg3 = (bool) true ;
16086 void *argp1 = 0 ;
16087 int res1 = 0 ;
16088 int val2 ;
16089 int ecode2 = 0 ;
16090 bool val3 ;
16091 int ecode3 = 0 ;
16092 PyObject * obj0 = 0 ;
16093 PyObject * obj1 = 0 ;
16094 PyObject * obj2 = 0 ;
16095 char * kwnames[] = {
16096 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16097 };
16098
16099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16103 }
16104 arg1 = reinterpret_cast< wxGrid * >(argp1);
16105 ecode2 = SWIG_AsVal_int(obj1, &val2);
16106 if (!SWIG_IsOK(ecode2)) {
16107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16108 }
16109 arg2 = static_cast< int >(val2);
16110 if (obj2) {
16111 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16112 if (!SWIG_IsOK(ecode3)) {
16113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16114 }
16115 arg3 = static_cast< bool >(val3);
16116 }
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 (arg1)->AutoSizeRow(arg2,arg3);
16120 wxPyEndAllowThreads(__tstate);
16121 if (PyErr_Occurred()) SWIG_fail;
16122 }
16123 resultobj = SWIG_Py_Void();
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16131 PyObject *resultobj = 0;
16132 wxGrid *arg1 = (wxGrid *) 0 ;
16133 bool arg2 = (bool) true ;
16134 void *argp1 = 0 ;
16135 int res1 = 0 ;
16136 bool val2 ;
16137 int ecode2 = 0 ;
16138 PyObject * obj0 = 0 ;
16139 PyObject * obj1 = 0 ;
16140 char * kwnames[] = {
16141 (char *) "self",(char *) "setAsMin", NULL
16142 };
16143
16144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16146 if (!SWIG_IsOK(res1)) {
16147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16148 }
16149 arg1 = reinterpret_cast< wxGrid * >(argp1);
16150 if (obj1) {
16151 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16152 if (!SWIG_IsOK(ecode2)) {
16153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16154 }
16155 arg2 = static_cast< bool >(val2);
16156 }
16157 {
16158 PyThreadState* __tstate = wxPyBeginAllowThreads();
16159 (arg1)->AutoSizeColumns(arg2);
16160 wxPyEndAllowThreads(__tstate);
16161 if (PyErr_Occurred()) SWIG_fail;
16162 }
16163 resultobj = SWIG_Py_Void();
16164 return resultobj;
16165 fail:
16166 return NULL;
16167 }
16168
16169
16170 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16171 PyObject *resultobj = 0;
16172 wxGrid *arg1 = (wxGrid *) 0 ;
16173 bool arg2 = (bool) true ;
16174 void *argp1 = 0 ;
16175 int res1 = 0 ;
16176 bool val2 ;
16177 int ecode2 = 0 ;
16178 PyObject * obj0 = 0 ;
16179 PyObject * obj1 = 0 ;
16180 char * kwnames[] = {
16181 (char *) "self",(char *) "setAsMin", NULL
16182 };
16183
16184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16186 if (!SWIG_IsOK(res1)) {
16187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16188 }
16189 arg1 = reinterpret_cast< wxGrid * >(argp1);
16190 if (obj1) {
16191 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16192 if (!SWIG_IsOK(ecode2)) {
16193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16194 }
16195 arg2 = static_cast< bool >(val2);
16196 }
16197 {
16198 PyThreadState* __tstate = wxPyBeginAllowThreads();
16199 (arg1)->AutoSizeRows(arg2);
16200 wxPyEndAllowThreads(__tstate);
16201 if (PyErr_Occurred()) SWIG_fail;
16202 }
16203 resultobj = SWIG_Py_Void();
16204 return resultobj;
16205 fail:
16206 return NULL;
16207 }
16208
16209
16210 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16211 PyObject *resultobj = 0;
16212 wxGrid *arg1 = (wxGrid *) 0 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 PyObject *swig_obj[1] ;
16216
16217 if (!args) SWIG_fail;
16218 swig_obj[0] = args;
16219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16222 }
16223 arg1 = reinterpret_cast< wxGrid * >(argp1);
16224 {
16225 PyThreadState* __tstate = wxPyBeginAllowThreads();
16226 (arg1)->AutoSize();
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 resultobj = SWIG_Py_Void();
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj = 0;
16239 wxGrid *arg1 = (wxGrid *) 0 ;
16240 int arg2 ;
16241 void *argp1 = 0 ;
16242 int res1 = 0 ;
16243 int val2 ;
16244 int ecode2 = 0 ;
16245 PyObject * obj0 = 0 ;
16246 PyObject * obj1 = 0 ;
16247 char * kwnames[] = {
16248 (char *) "self",(char *) "row", NULL
16249 };
16250
16251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16253 if (!SWIG_IsOK(res1)) {
16254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16255 }
16256 arg1 = reinterpret_cast< wxGrid * >(argp1);
16257 ecode2 = SWIG_AsVal_int(obj1, &val2);
16258 if (!SWIG_IsOK(ecode2)) {
16259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16260 }
16261 arg2 = static_cast< int >(val2);
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 (arg1)->AutoSizeRowLabelSize(arg2);
16265 wxPyEndAllowThreads(__tstate);
16266 if (PyErr_Occurred()) SWIG_fail;
16267 }
16268 resultobj = SWIG_Py_Void();
16269 return resultobj;
16270 fail:
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj = 0;
16277 wxGrid *arg1 = (wxGrid *) 0 ;
16278 int arg2 ;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 int val2 ;
16282 int ecode2 = 0 ;
16283 PyObject * obj0 = 0 ;
16284 PyObject * obj1 = 0 ;
16285 char * kwnames[] = {
16286 (char *) "self",(char *) "col", NULL
16287 };
16288
16289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16291 if (!SWIG_IsOK(res1)) {
16292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16293 }
16294 arg1 = reinterpret_cast< wxGrid * >(argp1);
16295 ecode2 = SWIG_AsVal_int(obj1, &val2);
16296 if (!SWIG_IsOK(ecode2)) {
16297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16298 }
16299 arg2 = static_cast< int >(val2);
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 (arg1)->AutoSizeColLabelSize(arg2);
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 resultobj = SWIG_Py_Void();
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16314 PyObject *resultobj = 0;
16315 wxGrid *arg1 = (wxGrid *) 0 ;
16316 int arg2 ;
16317 int arg3 ;
16318 void *argp1 = 0 ;
16319 int res1 = 0 ;
16320 int val2 ;
16321 int ecode2 = 0 ;
16322 int val3 ;
16323 int ecode3 = 0 ;
16324 PyObject * obj0 = 0 ;
16325 PyObject * obj1 = 0 ;
16326 PyObject * obj2 = 0 ;
16327 char * kwnames[] = {
16328 (char *) "self",(char *) "col",(char *) "width", NULL
16329 };
16330
16331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16333 if (!SWIG_IsOK(res1)) {
16334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16335 }
16336 arg1 = reinterpret_cast< wxGrid * >(argp1);
16337 ecode2 = SWIG_AsVal_int(obj1, &val2);
16338 if (!SWIG_IsOK(ecode2)) {
16339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16340 }
16341 arg2 = static_cast< int >(val2);
16342 ecode3 = SWIG_AsVal_int(obj2, &val3);
16343 if (!SWIG_IsOK(ecode3)) {
16344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16345 }
16346 arg3 = static_cast< int >(val3);
16347 {
16348 PyThreadState* __tstate = wxPyBeginAllowThreads();
16349 (arg1)->SetColMinimalWidth(arg2,arg3);
16350 wxPyEndAllowThreads(__tstate);
16351 if (PyErr_Occurred()) SWIG_fail;
16352 }
16353 resultobj = SWIG_Py_Void();
16354 return resultobj;
16355 fail:
16356 return NULL;
16357 }
16358
16359
16360 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16361 PyObject *resultobj = 0;
16362 wxGrid *arg1 = (wxGrid *) 0 ;
16363 int arg2 ;
16364 int arg3 ;
16365 void *argp1 = 0 ;
16366 int res1 = 0 ;
16367 int val2 ;
16368 int ecode2 = 0 ;
16369 int val3 ;
16370 int ecode3 = 0 ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 PyObject * obj2 = 0 ;
16374 char * kwnames[] = {
16375 (char *) "self",(char *) "row",(char *) "width", NULL
16376 };
16377
16378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16380 if (!SWIG_IsOK(res1)) {
16381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16382 }
16383 arg1 = reinterpret_cast< wxGrid * >(argp1);
16384 ecode2 = SWIG_AsVal_int(obj1, &val2);
16385 if (!SWIG_IsOK(ecode2)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16387 }
16388 arg2 = static_cast< int >(val2);
16389 ecode3 = SWIG_AsVal_int(obj2, &val3);
16390 if (!SWIG_IsOK(ecode3)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16392 }
16393 arg3 = static_cast< int >(val3);
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 (arg1)->SetRowMinimalHeight(arg2,arg3);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 resultobj = SWIG_Py_Void();
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj = 0;
16409 wxGrid *arg1 = (wxGrid *) 0 ;
16410 int arg2 ;
16411 void *argp1 = 0 ;
16412 int res1 = 0 ;
16413 int val2 ;
16414 int ecode2 = 0 ;
16415 PyObject * obj0 = 0 ;
16416 PyObject * obj1 = 0 ;
16417 char * kwnames[] = {
16418 (char *) "self",(char *) "width", NULL
16419 };
16420
16421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16423 if (!SWIG_IsOK(res1)) {
16424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16425 }
16426 arg1 = reinterpret_cast< wxGrid * >(argp1);
16427 ecode2 = SWIG_AsVal_int(obj1, &val2);
16428 if (!SWIG_IsOK(ecode2)) {
16429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16430 }
16431 arg2 = static_cast< int >(val2);
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 (arg1)->SetColMinimalAcceptableWidth(arg2);
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 resultobj = SWIG_Py_Void();
16439 return resultobj;
16440 fail:
16441 return NULL;
16442 }
16443
16444
16445 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16446 PyObject *resultobj = 0;
16447 wxGrid *arg1 = (wxGrid *) 0 ;
16448 int arg2 ;
16449 void *argp1 = 0 ;
16450 int res1 = 0 ;
16451 int val2 ;
16452 int ecode2 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 PyObject * obj1 = 0 ;
16455 char * kwnames[] = {
16456 (char *) "self",(char *) "width", NULL
16457 };
16458
16459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16463 }
16464 arg1 = reinterpret_cast< wxGrid * >(argp1);
16465 ecode2 = SWIG_AsVal_int(obj1, &val2);
16466 if (!SWIG_IsOK(ecode2)) {
16467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16468 }
16469 arg2 = static_cast< int >(val2);
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 resultobj = SWIG_Py_Void();
16477 return resultobj;
16478 fail:
16479 return NULL;
16480 }
16481
16482
16483 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16484 PyObject *resultobj = 0;
16485 wxGrid *arg1 = (wxGrid *) 0 ;
16486 int result;
16487 void *argp1 = 0 ;
16488 int res1 = 0 ;
16489 PyObject *swig_obj[1] ;
16490
16491 if (!args) SWIG_fail;
16492 swig_obj[0] = args;
16493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16494 if (!SWIG_IsOK(res1)) {
16495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16496 }
16497 arg1 = reinterpret_cast< wxGrid * >(argp1);
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_From_int(static_cast< int >(result));
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16512 PyObject *resultobj = 0;
16513 wxGrid *arg1 = (wxGrid *) 0 ;
16514 int result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 PyObject *swig_obj[1] ;
16518
16519 if (!args) SWIG_fail;
16520 swig_obj[0] = args;
16521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16522 if (!SWIG_IsOK(res1)) {
16523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16524 }
16525 arg1 = reinterpret_cast< wxGrid * >(argp1);
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 resultobj = SWIG_From_int(static_cast< int >(result));
16533 return resultobj;
16534 fail:
16535 return NULL;
16536 }
16537
16538
16539 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16540 PyObject *resultobj = 0;
16541 wxGrid *arg1 = (wxGrid *) 0 ;
16542 wxColour *arg2 = 0 ;
16543 void *argp1 = 0 ;
16544 int res1 = 0 ;
16545 wxColour temp2 ;
16546 PyObject * obj0 = 0 ;
16547 PyObject * obj1 = 0 ;
16548 char * kwnames[] = {
16549 (char *) "self",(char *)"arg2", NULL
16550 };
16551
16552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16554 if (!SWIG_IsOK(res1)) {
16555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16556 }
16557 arg1 = reinterpret_cast< wxGrid * >(argp1);
16558 {
16559 arg2 = &temp2;
16560 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16561 }
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 resultobj = SWIG_Py_Void();
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj = 0;
16577 wxGrid *arg1 = (wxGrid *) 0 ;
16578 int arg2 ;
16579 int arg3 ;
16580 wxColour *arg4 = 0 ;
16581 void *argp1 = 0 ;
16582 int res1 = 0 ;
16583 int val2 ;
16584 int ecode2 = 0 ;
16585 int val3 ;
16586 int ecode3 = 0 ;
16587 wxColour temp4 ;
16588 PyObject * obj0 = 0 ;
16589 PyObject * obj1 = 0 ;
16590 PyObject * obj2 = 0 ;
16591 PyObject * obj3 = 0 ;
16592 char * kwnames[] = {
16593 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16594 };
16595
16596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16598 if (!SWIG_IsOK(res1)) {
16599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16600 }
16601 arg1 = reinterpret_cast< wxGrid * >(argp1);
16602 ecode2 = SWIG_AsVal_int(obj1, &val2);
16603 if (!SWIG_IsOK(ecode2)) {
16604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16605 }
16606 arg2 = static_cast< int >(val2);
16607 ecode3 = SWIG_AsVal_int(obj2, &val3);
16608 if (!SWIG_IsOK(ecode3)) {
16609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16610 }
16611 arg3 = static_cast< int >(val3);
16612 {
16613 arg4 = &temp4;
16614 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16615 }
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = SWIG_Py_Void();
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj = 0;
16631 wxGrid *arg1 = (wxGrid *) 0 ;
16632 wxColour *arg2 = 0 ;
16633 void *argp1 = 0 ;
16634 int res1 = 0 ;
16635 wxColour temp2 ;
16636 PyObject * obj0 = 0 ;
16637 PyObject * obj1 = 0 ;
16638 char * kwnames[] = {
16639 (char *) "self",(char *)"arg2", NULL
16640 };
16641
16642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16644 if (!SWIG_IsOK(res1)) {
16645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16646 }
16647 arg1 = reinterpret_cast< wxGrid * >(argp1);
16648 {
16649 arg2 = &temp2;
16650 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16651 }
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_Py_Void();
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj = 0;
16667 wxGrid *arg1 = (wxGrid *) 0 ;
16668 int arg2 ;
16669 int arg3 ;
16670 wxColour *arg4 = 0 ;
16671 void *argp1 = 0 ;
16672 int res1 = 0 ;
16673 int val2 ;
16674 int ecode2 = 0 ;
16675 int val3 ;
16676 int ecode3 = 0 ;
16677 wxColour temp4 ;
16678 PyObject * obj0 = 0 ;
16679 PyObject * obj1 = 0 ;
16680 PyObject * obj2 = 0 ;
16681 PyObject * obj3 = 0 ;
16682 char * kwnames[] = {
16683 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16684 };
16685
16686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16688 if (!SWIG_IsOK(res1)) {
16689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16690 }
16691 arg1 = reinterpret_cast< wxGrid * >(argp1);
16692 ecode2 = SWIG_AsVal_int(obj1, &val2);
16693 if (!SWIG_IsOK(ecode2)) {
16694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16695 }
16696 arg2 = static_cast< int >(val2);
16697 ecode3 = SWIG_AsVal_int(obj2, &val3);
16698 if (!SWIG_IsOK(ecode3)) {
16699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16700 }
16701 arg3 = static_cast< int >(val3);
16702 {
16703 arg4 = &temp4;
16704 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16705 }
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 resultobj = SWIG_Py_Void();
16713 return resultobj;
16714 fail:
16715 return NULL;
16716 }
16717
16718
16719 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16720 PyObject *resultobj = 0;
16721 wxGrid *arg1 = (wxGrid *) 0 ;
16722 wxFont *arg2 = 0 ;
16723 void *argp1 = 0 ;
16724 int res1 = 0 ;
16725 void *argp2 = 0 ;
16726 int res2 = 0 ;
16727 PyObject * obj0 = 0 ;
16728 PyObject * obj1 = 0 ;
16729 char * kwnames[] = {
16730 (char *) "self",(char *)"arg2", NULL
16731 };
16732
16733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16735 if (!SWIG_IsOK(res1)) {
16736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16737 }
16738 arg1 = reinterpret_cast< wxGrid * >(argp1);
16739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16740 if (!SWIG_IsOK(res2)) {
16741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16742 }
16743 if (!argp2) {
16744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16745 }
16746 arg2 = reinterpret_cast< wxFont * >(argp2);
16747 {
16748 PyThreadState* __tstate = wxPyBeginAllowThreads();
16749 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 resultobj = SWIG_Py_Void();
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj = 0;
16762 wxGrid *arg1 = (wxGrid *) 0 ;
16763 int arg2 ;
16764 int arg3 ;
16765 wxFont *arg4 = 0 ;
16766 void *argp1 = 0 ;
16767 int res1 = 0 ;
16768 int val2 ;
16769 int ecode2 = 0 ;
16770 int val3 ;
16771 int ecode3 = 0 ;
16772 void *argp4 = 0 ;
16773 int res4 = 0 ;
16774 PyObject * obj0 = 0 ;
16775 PyObject * obj1 = 0 ;
16776 PyObject * obj2 = 0 ;
16777 PyObject * obj3 = 0 ;
16778 char * kwnames[] = {
16779 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16780 };
16781
16782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16784 if (!SWIG_IsOK(res1)) {
16785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16786 }
16787 arg1 = reinterpret_cast< wxGrid * >(argp1);
16788 ecode2 = SWIG_AsVal_int(obj1, &val2);
16789 if (!SWIG_IsOK(ecode2)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16791 }
16792 arg2 = static_cast< int >(val2);
16793 ecode3 = SWIG_AsVal_int(obj2, &val3);
16794 if (!SWIG_IsOK(ecode3)) {
16795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16796 }
16797 arg3 = static_cast< int >(val3);
16798 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16799 if (!SWIG_IsOK(res4)) {
16800 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16801 }
16802 if (!argp4) {
16803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16804 }
16805 arg4 = reinterpret_cast< wxFont * >(argp4);
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_Py_Void();
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxGrid *arg1 = (wxGrid *) 0 ;
16822 int arg2 ;
16823 int arg3 ;
16824 void *argp1 = 0 ;
16825 int res1 = 0 ;
16826 int val2 ;
16827 int ecode2 = 0 ;
16828 int val3 ;
16829 int ecode3 = 0 ;
16830 PyObject * obj0 = 0 ;
16831 PyObject * obj1 = 0 ;
16832 PyObject * obj2 = 0 ;
16833 char * kwnames[] = {
16834 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16835 };
16836
16837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16839 if (!SWIG_IsOK(res1)) {
16840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16841 }
16842 arg1 = reinterpret_cast< wxGrid * >(argp1);
16843 ecode2 = SWIG_AsVal_int(obj1, &val2);
16844 if (!SWIG_IsOK(ecode2)) {
16845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16846 }
16847 arg2 = static_cast< int >(val2);
16848 ecode3 = SWIG_AsVal_int(obj2, &val3);
16849 if (!SWIG_IsOK(ecode3)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16851 }
16852 arg3 = static_cast< int >(val3);
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = SWIG_Py_Void();
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj = 0;
16868 wxGrid *arg1 = (wxGrid *) 0 ;
16869 int arg2 ;
16870 int arg3 ;
16871 int arg4 ;
16872 int arg5 ;
16873 void *argp1 = 0 ;
16874 int res1 = 0 ;
16875 int val2 ;
16876 int ecode2 = 0 ;
16877 int val3 ;
16878 int ecode3 = 0 ;
16879 int val4 ;
16880 int ecode4 = 0 ;
16881 int val5 ;
16882 int ecode5 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 PyObject * obj1 = 0 ;
16885 PyObject * obj2 = 0 ;
16886 PyObject * obj3 = 0 ;
16887 PyObject * obj4 = 0 ;
16888 char * kwnames[] = {
16889 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16890 };
16891
16892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16894 if (!SWIG_IsOK(res1)) {
16895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16896 }
16897 arg1 = reinterpret_cast< wxGrid * >(argp1);
16898 ecode2 = SWIG_AsVal_int(obj1, &val2);
16899 if (!SWIG_IsOK(ecode2)) {
16900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16901 }
16902 arg2 = static_cast< int >(val2);
16903 ecode3 = SWIG_AsVal_int(obj2, &val3);
16904 if (!SWIG_IsOK(ecode3)) {
16905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16906 }
16907 arg3 = static_cast< int >(val3);
16908 ecode4 = SWIG_AsVal_int(obj3, &val4);
16909 if (!SWIG_IsOK(ecode4)) {
16910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16911 }
16912 arg4 = static_cast< int >(val4);
16913 ecode5 = SWIG_AsVal_int(obj4, &val5);
16914 if (!SWIG_IsOK(ecode5)) {
16915 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16916 }
16917 arg5 = static_cast< int >(val5);
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 resultobj = SWIG_Py_Void();
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxGrid *arg1 = (wxGrid *) 0 ;
16934 bool arg2 ;
16935 void *argp1 = 0 ;
16936 int res1 = 0 ;
16937 bool val2 ;
16938 int ecode2 = 0 ;
16939 PyObject * obj0 = 0 ;
16940 PyObject * obj1 = 0 ;
16941 char * kwnames[] = {
16942 (char *) "self",(char *) "allow", NULL
16943 };
16944
16945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16947 if (!SWIG_IsOK(res1)) {
16948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16949 }
16950 arg1 = reinterpret_cast< wxGrid * >(argp1);
16951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16952 if (!SWIG_IsOK(ecode2)) {
16953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16954 }
16955 arg2 = static_cast< bool >(val2);
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 (arg1)->SetDefaultCellOverflow(arg2);
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_Py_Void();
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj = 0;
16971 wxGrid *arg1 = (wxGrid *) 0 ;
16972 int arg2 ;
16973 int arg3 ;
16974 bool arg4 ;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 int val2 ;
16978 int ecode2 = 0 ;
16979 int val3 ;
16980 int ecode3 = 0 ;
16981 bool val4 ;
16982 int ecode4 = 0 ;
16983 PyObject * obj0 = 0 ;
16984 PyObject * obj1 = 0 ;
16985 PyObject * obj2 = 0 ;
16986 PyObject * obj3 = 0 ;
16987 char * kwnames[] = {
16988 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16989 };
16990
16991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16993 if (!SWIG_IsOK(res1)) {
16994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16995 }
16996 arg1 = reinterpret_cast< wxGrid * >(argp1);
16997 ecode2 = SWIG_AsVal_int(obj1, &val2);
16998 if (!SWIG_IsOK(ecode2)) {
16999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17000 }
17001 arg2 = static_cast< int >(val2);
17002 ecode3 = SWIG_AsVal_int(obj2, &val3);
17003 if (!SWIG_IsOK(ecode3)) {
17004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17005 }
17006 arg3 = static_cast< int >(val3);
17007 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17008 if (!SWIG_IsOK(ecode4)) {
17009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17010 }
17011 arg4 = static_cast< bool >(val4);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = SWIG_Py_Void();
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj = 0;
17027 wxGrid *arg1 = (wxGrid *) 0 ;
17028 int arg2 ;
17029 int arg3 ;
17030 int arg4 ;
17031 int arg5 ;
17032 void *argp1 = 0 ;
17033 int res1 = 0 ;
17034 int val2 ;
17035 int ecode2 = 0 ;
17036 int val3 ;
17037 int ecode3 = 0 ;
17038 int val4 ;
17039 int ecode4 = 0 ;
17040 int val5 ;
17041 int ecode5 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 PyObject * obj4 = 0 ;
17047 char * kwnames[] = {
17048 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17049 };
17050
17051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17053 if (!SWIG_IsOK(res1)) {
17054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17055 }
17056 arg1 = reinterpret_cast< wxGrid * >(argp1);
17057 ecode2 = SWIG_AsVal_int(obj1, &val2);
17058 if (!SWIG_IsOK(ecode2)) {
17059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17060 }
17061 arg2 = static_cast< int >(val2);
17062 ecode3 = SWIG_AsVal_int(obj2, &val3);
17063 if (!SWIG_IsOK(ecode3)) {
17064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17065 }
17066 arg3 = static_cast< int >(val3);
17067 ecode4 = SWIG_AsVal_int(obj3, &val4);
17068 if (!SWIG_IsOK(ecode4)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17070 }
17071 arg4 = static_cast< int >(val4);
17072 ecode5 = SWIG_AsVal_int(obj4, &val5);
17073 if (!SWIG_IsOK(ecode5)) {
17074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17075 }
17076 arg5 = static_cast< int >(val5);
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 resultobj = SWIG_Py_Void();
17084 return resultobj;
17085 fail:
17086 return NULL;
17087 }
17088
17089
17090 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17091 PyObject *resultobj = 0;
17092 wxGrid *arg1 = (wxGrid *) 0 ;
17093 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17094 void *argp1 = 0 ;
17095 int res1 = 0 ;
17096 void *argp2 = 0 ;
17097 int res2 = 0 ;
17098 PyObject * obj0 = 0 ;
17099 PyObject * obj1 = 0 ;
17100 char * kwnames[] = {
17101 (char *) "self",(char *) "renderer", NULL
17102 };
17103
17104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17106 if (!SWIG_IsOK(res1)) {
17107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17108 }
17109 arg1 = reinterpret_cast< wxGrid * >(argp1);
17110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17111 if (!SWIG_IsOK(res2)) {
17112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17113 }
17114 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17115 {
17116 PyThreadState* __tstate = wxPyBeginAllowThreads();
17117 (arg1)->SetDefaultRenderer(arg2);
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 resultobj = SWIG_Py_Void();
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj = 0;
17130 wxGrid *arg1 = (wxGrid *) 0 ;
17131 int arg2 ;
17132 int arg3 ;
17133 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17134 void *argp1 = 0 ;
17135 int res1 = 0 ;
17136 int val2 ;
17137 int ecode2 = 0 ;
17138 int val3 ;
17139 int ecode3 = 0 ;
17140 void *argp4 = 0 ;
17141 int res4 = 0 ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 PyObject * obj2 = 0 ;
17145 PyObject * obj3 = 0 ;
17146 char * kwnames[] = {
17147 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17148 };
17149
17150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17152 if (!SWIG_IsOK(res1)) {
17153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17154 }
17155 arg1 = reinterpret_cast< wxGrid * >(argp1);
17156 ecode2 = SWIG_AsVal_int(obj1, &val2);
17157 if (!SWIG_IsOK(ecode2)) {
17158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17159 }
17160 arg2 = static_cast< int >(val2);
17161 ecode3 = SWIG_AsVal_int(obj2, &val3);
17162 if (!SWIG_IsOK(ecode3)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17164 }
17165 arg3 = static_cast< int >(val3);
17166 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17167 if (!SWIG_IsOK(res4)) {
17168 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17169 }
17170 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17171 {
17172 PyThreadState* __tstate = wxPyBeginAllowThreads();
17173 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 resultobj = SWIG_Py_Void();
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17185 PyObject *resultobj = 0;
17186 wxGrid *arg1 = (wxGrid *) 0 ;
17187 wxGridCellRenderer *result = 0 ;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 PyObject *swig_obj[1] ;
17191
17192 if (!args) SWIG_fail;
17193 swig_obj[0] = args;
17194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17195 if (!SWIG_IsOK(res1)) {
17196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17197 }
17198 arg1 = reinterpret_cast< wxGrid * >(argp1);
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 {
17206 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17207 }
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj = 0;
17216 wxGrid *arg1 = (wxGrid *) 0 ;
17217 int arg2 ;
17218 int arg3 ;
17219 wxGridCellRenderer *result = 0 ;
17220 void *argp1 = 0 ;
17221 int res1 = 0 ;
17222 int val2 ;
17223 int ecode2 = 0 ;
17224 int val3 ;
17225 int ecode3 = 0 ;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 PyObject * obj2 = 0 ;
17229 char * kwnames[] = {
17230 (char *) "self",(char *) "row",(char *) "col", NULL
17231 };
17232
17233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17235 if (!SWIG_IsOK(res1)) {
17236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17237 }
17238 arg1 = reinterpret_cast< wxGrid * >(argp1);
17239 ecode2 = SWIG_AsVal_int(obj1, &val2);
17240 if (!SWIG_IsOK(ecode2)) {
17241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17242 }
17243 arg2 = static_cast< int >(val2);
17244 ecode3 = SWIG_AsVal_int(obj2, &val3);
17245 if (!SWIG_IsOK(ecode3)) {
17246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17247 }
17248 arg3 = static_cast< int >(val3);
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17252 wxPyEndAllowThreads(__tstate);
17253 if (PyErr_Occurred()) SWIG_fail;
17254 }
17255 {
17256 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17257 }
17258 return resultobj;
17259 fail:
17260 return NULL;
17261 }
17262
17263
17264 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17265 PyObject *resultobj = 0;
17266 wxGrid *arg1 = (wxGrid *) 0 ;
17267 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17268 void *argp1 = 0 ;
17269 int res1 = 0 ;
17270 void *argp2 = 0 ;
17271 int res2 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 char * kwnames[] = {
17275 (char *) "self",(char *) "editor", NULL
17276 };
17277
17278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17280 if (!SWIG_IsOK(res1)) {
17281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17282 }
17283 arg1 = reinterpret_cast< wxGrid * >(argp1);
17284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17285 if (!SWIG_IsOK(res2)) {
17286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17287 }
17288 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 (arg1)->SetDefaultEditor(arg2);
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 resultobj = SWIG_Py_Void();
17296 return resultobj;
17297 fail:
17298 return NULL;
17299 }
17300
17301
17302 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj = 0;
17304 wxGrid *arg1 = (wxGrid *) 0 ;
17305 int arg2 ;
17306 int arg3 ;
17307 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17308 void *argp1 = 0 ;
17309 int res1 = 0 ;
17310 int val2 ;
17311 int ecode2 = 0 ;
17312 int val3 ;
17313 int ecode3 = 0 ;
17314 void *argp4 = 0 ;
17315 int res4 = 0 ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 PyObject * obj2 = 0 ;
17319 PyObject * obj3 = 0 ;
17320 char * kwnames[] = {
17321 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17322 };
17323
17324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17326 if (!SWIG_IsOK(res1)) {
17327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17328 }
17329 arg1 = reinterpret_cast< wxGrid * >(argp1);
17330 ecode2 = SWIG_AsVal_int(obj1, &val2);
17331 if (!SWIG_IsOK(ecode2)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17333 }
17334 arg2 = static_cast< int >(val2);
17335 ecode3 = SWIG_AsVal_int(obj2, &val3);
17336 if (!SWIG_IsOK(ecode3)) {
17337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17338 }
17339 arg3 = static_cast< int >(val3);
17340 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17341 if (!SWIG_IsOK(res4)) {
17342 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17343 }
17344 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 (arg1)->SetCellEditor(arg2,arg3,arg4);
17348 wxPyEndAllowThreads(__tstate);
17349 if (PyErr_Occurred()) SWIG_fail;
17350 }
17351 resultobj = SWIG_Py_Void();
17352 return resultobj;
17353 fail:
17354 return NULL;
17355 }
17356
17357
17358 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 PyObject *resultobj = 0;
17360 wxGrid *arg1 = (wxGrid *) 0 ;
17361 wxGridCellEditor *result = 0 ;
17362 void *argp1 = 0 ;
17363 int res1 = 0 ;
17364 PyObject *swig_obj[1] ;
17365
17366 if (!args) SWIG_fail;
17367 swig_obj[0] = args;
17368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17369 if (!SWIG_IsOK(res1)) {
17370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17371 }
17372 arg1 = reinterpret_cast< wxGrid * >(argp1);
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17381 }
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxGrid *arg1 = (wxGrid *) 0 ;
17391 int arg2 ;
17392 int arg3 ;
17393 wxGridCellEditor *result = 0 ;
17394 void *argp1 = 0 ;
17395 int res1 = 0 ;
17396 int val2 ;
17397 int ecode2 = 0 ;
17398 int val3 ;
17399 int ecode3 = 0 ;
17400 PyObject * obj0 = 0 ;
17401 PyObject * obj1 = 0 ;
17402 PyObject * obj2 = 0 ;
17403 char * kwnames[] = {
17404 (char *) "self",(char *) "row",(char *) "col", NULL
17405 };
17406
17407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17409 if (!SWIG_IsOK(res1)) {
17410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17411 }
17412 arg1 = reinterpret_cast< wxGrid * >(argp1);
17413 ecode2 = SWIG_AsVal_int(obj1, &val2);
17414 if (!SWIG_IsOK(ecode2)) {
17415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17416 }
17417 arg2 = static_cast< int >(val2);
17418 ecode3 = SWIG_AsVal_int(obj2, &val3);
17419 if (!SWIG_IsOK(ecode3)) {
17420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17421 }
17422 arg3 = static_cast< int >(val3);
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17431 }
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj = 0;
17440 wxGrid *arg1 = (wxGrid *) 0 ;
17441 int arg2 ;
17442 int arg3 ;
17443 wxString result;
17444 void *argp1 = 0 ;
17445 int res1 = 0 ;
17446 int val2 ;
17447 int ecode2 = 0 ;
17448 int val3 ;
17449 int ecode3 = 0 ;
17450 PyObject * obj0 = 0 ;
17451 PyObject * obj1 = 0 ;
17452 PyObject * obj2 = 0 ;
17453 char * kwnames[] = {
17454 (char *) "self",(char *) "row",(char *) "col", NULL
17455 };
17456
17457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17459 if (!SWIG_IsOK(res1)) {
17460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17461 }
17462 arg1 = reinterpret_cast< wxGrid * >(argp1);
17463 ecode2 = SWIG_AsVal_int(obj1, &val2);
17464 if (!SWIG_IsOK(ecode2)) {
17465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17466 }
17467 arg2 = static_cast< int >(val2);
17468 ecode3 = SWIG_AsVal_int(obj2, &val3);
17469 if (!SWIG_IsOK(ecode3)) {
17470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17471 }
17472 arg3 = static_cast< int >(val3);
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (arg1)->GetCellValue(arg2,arg3);
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 {
17480 #if wxUSE_UNICODE
17481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17482 #else
17483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17484 #endif
17485 }
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17493 PyObject *resultobj = 0;
17494 wxGrid *arg1 = (wxGrid *) 0 ;
17495 int arg2 ;
17496 int arg3 ;
17497 wxString *arg4 = 0 ;
17498 void *argp1 = 0 ;
17499 int res1 = 0 ;
17500 int val2 ;
17501 int ecode2 = 0 ;
17502 int val3 ;
17503 int ecode3 = 0 ;
17504 bool temp4 = false ;
17505 PyObject * obj0 = 0 ;
17506 PyObject * obj1 = 0 ;
17507 PyObject * obj2 = 0 ;
17508 PyObject * obj3 = 0 ;
17509 char * kwnames[] = {
17510 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17511 };
17512
17513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17515 if (!SWIG_IsOK(res1)) {
17516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17517 }
17518 arg1 = reinterpret_cast< wxGrid * >(argp1);
17519 ecode2 = SWIG_AsVal_int(obj1, &val2);
17520 if (!SWIG_IsOK(ecode2)) {
17521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17522 }
17523 arg2 = static_cast< int >(val2);
17524 ecode3 = SWIG_AsVal_int(obj2, &val3);
17525 if (!SWIG_IsOK(ecode3)) {
17526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17527 }
17528 arg3 = static_cast< int >(val3);
17529 {
17530 arg4 = wxString_in_helper(obj3);
17531 if (arg4 == NULL) SWIG_fail;
17532 temp4 = true;
17533 }
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 resultobj = SWIG_Py_Void();
17541 {
17542 if (temp4)
17543 delete arg4;
17544 }
17545 return resultobj;
17546 fail:
17547 {
17548 if (temp4)
17549 delete arg4;
17550 }
17551 return NULL;
17552 }
17553
17554
17555 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj = 0;
17557 wxGrid *arg1 = (wxGrid *) 0 ;
17558 int arg2 ;
17559 int arg3 ;
17560 bool result;
17561 void *argp1 = 0 ;
17562 int res1 = 0 ;
17563 int val2 ;
17564 int ecode2 = 0 ;
17565 int val3 ;
17566 int ecode3 = 0 ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 PyObject * obj2 = 0 ;
17570 char * kwnames[] = {
17571 (char *) "self",(char *) "row",(char *) "col", NULL
17572 };
17573
17574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17576 if (!SWIG_IsOK(res1)) {
17577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17578 }
17579 arg1 = reinterpret_cast< wxGrid * >(argp1);
17580 ecode2 = SWIG_AsVal_int(obj1, &val2);
17581 if (!SWIG_IsOK(ecode2)) {
17582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17583 }
17584 arg2 = static_cast< int >(val2);
17585 ecode3 = SWIG_AsVal_int(obj2, &val3);
17586 if (!SWIG_IsOK(ecode3)) {
17587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17588 }
17589 arg3 = static_cast< int >(val3);
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17598 }
17599 return resultobj;
17600 fail:
17601 return NULL;
17602 }
17603
17604
17605 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17606 PyObject *resultobj = 0;
17607 wxGrid *arg1 = (wxGrid *) 0 ;
17608 int arg2 ;
17609 int arg3 ;
17610 bool arg4 = (bool) true ;
17611 void *argp1 = 0 ;
17612 int res1 = 0 ;
17613 int val2 ;
17614 int ecode2 = 0 ;
17615 int val3 ;
17616 int ecode3 = 0 ;
17617 bool val4 ;
17618 int ecode4 = 0 ;
17619 PyObject * obj0 = 0 ;
17620 PyObject * obj1 = 0 ;
17621 PyObject * obj2 = 0 ;
17622 PyObject * obj3 = 0 ;
17623 char * kwnames[] = {
17624 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17625 };
17626
17627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17629 if (!SWIG_IsOK(res1)) {
17630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17631 }
17632 arg1 = reinterpret_cast< wxGrid * >(argp1);
17633 ecode2 = SWIG_AsVal_int(obj1, &val2);
17634 if (!SWIG_IsOK(ecode2)) {
17635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17636 }
17637 arg2 = static_cast< int >(val2);
17638 ecode3 = SWIG_AsVal_int(obj2, &val3);
17639 if (!SWIG_IsOK(ecode3)) {
17640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17641 }
17642 arg3 = static_cast< int >(val3);
17643 if (obj3) {
17644 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17645 if (!SWIG_IsOK(ecode4)) {
17646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17647 }
17648 arg4 = static_cast< bool >(val4);
17649 }
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 (arg1)->SetReadOnly(arg2,arg3,arg4);
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 resultobj = SWIG_Py_Void();
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj = 0;
17665 wxGrid *arg1 = (wxGrid *) 0 ;
17666 int arg2 ;
17667 bool arg3 = (bool) false ;
17668 void *argp1 = 0 ;
17669 int res1 = 0 ;
17670 int val2 ;
17671 int ecode2 = 0 ;
17672 bool val3 ;
17673 int ecode3 = 0 ;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 PyObject * obj2 = 0 ;
17677 char * kwnames[] = {
17678 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17679 };
17680
17681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17683 if (!SWIG_IsOK(res1)) {
17684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17685 }
17686 arg1 = reinterpret_cast< wxGrid * >(argp1);
17687 ecode2 = SWIG_AsVal_int(obj1, &val2);
17688 if (!SWIG_IsOK(ecode2)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17690 }
17691 arg2 = static_cast< int >(val2);
17692 if (obj2) {
17693 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17694 if (!SWIG_IsOK(ecode3)) {
17695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17696 }
17697 arg3 = static_cast< bool >(val3);
17698 }
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 (arg1)->SelectRow(arg2,arg3);
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_Py_Void();
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17713 PyObject *resultobj = 0;
17714 wxGrid *arg1 = (wxGrid *) 0 ;
17715 int arg2 ;
17716 bool arg3 = (bool) false ;
17717 void *argp1 = 0 ;
17718 int res1 = 0 ;
17719 int val2 ;
17720 int ecode2 = 0 ;
17721 bool val3 ;
17722 int ecode3 = 0 ;
17723 PyObject * obj0 = 0 ;
17724 PyObject * obj1 = 0 ;
17725 PyObject * obj2 = 0 ;
17726 char * kwnames[] = {
17727 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17728 };
17729
17730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17732 if (!SWIG_IsOK(res1)) {
17733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17734 }
17735 arg1 = reinterpret_cast< wxGrid * >(argp1);
17736 ecode2 = SWIG_AsVal_int(obj1, &val2);
17737 if (!SWIG_IsOK(ecode2)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17739 }
17740 arg2 = static_cast< int >(val2);
17741 if (obj2) {
17742 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17743 if (!SWIG_IsOK(ecode3)) {
17744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17745 }
17746 arg3 = static_cast< bool >(val3);
17747 }
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 (arg1)->SelectCol(arg2,arg3);
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 resultobj = SWIG_Py_Void();
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = 0;
17763 wxGrid *arg1 = (wxGrid *) 0 ;
17764 int arg2 ;
17765 int arg3 ;
17766 int arg4 ;
17767 int arg5 ;
17768 bool arg6 = (bool) false ;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 int val2 ;
17772 int ecode2 = 0 ;
17773 int val3 ;
17774 int ecode3 = 0 ;
17775 int val4 ;
17776 int ecode4 = 0 ;
17777 int val5 ;
17778 int ecode5 = 0 ;
17779 bool val6 ;
17780 int ecode6 = 0 ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 PyObject * obj2 = 0 ;
17784 PyObject * obj3 = 0 ;
17785 PyObject * obj4 = 0 ;
17786 PyObject * obj5 = 0 ;
17787 char * kwnames[] = {
17788 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17789 };
17790
17791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17793 if (!SWIG_IsOK(res1)) {
17794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17795 }
17796 arg1 = reinterpret_cast< wxGrid * >(argp1);
17797 ecode2 = SWIG_AsVal_int(obj1, &val2);
17798 if (!SWIG_IsOK(ecode2)) {
17799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17800 }
17801 arg2 = static_cast< int >(val2);
17802 ecode3 = SWIG_AsVal_int(obj2, &val3);
17803 if (!SWIG_IsOK(ecode3)) {
17804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17805 }
17806 arg3 = static_cast< int >(val3);
17807 ecode4 = SWIG_AsVal_int(obj3, &val4);
17808 if (!SWIG_IsOK(ecode4)) {
17809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17810 }
17811 arg4 = static_cast< int >(val4);
17812 ecode5 = SWIG_AsVal_int(obj4, &val5);
17813 if (!SWIG_IsOK(ecode5)) {
17814 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17815 }
17816 arg5 = static_cast< int >(val5);
17817 if (obj5) {
17818 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17819 if (!SWIG_IsOK(ecode6)) {
17820 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17821 }
17822 arg6 = static_cast< bool >(val6);
17823 }
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 resultobj = SWIG_Py_Void();
17831 return resultobj;
17832 fail:
17833 return NULL;
17834 }
17835
17836
17837 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17838 PyObject *resultobj = 0;
17839 wxGrid *arg1 = (wxGrid *) 0 ;
17840 void *argp1 = 0 ;
17841 int res1 = 0 ;
17842 PyObject *swig_obj[1] ;
17843
17844 if (!args) SWIG_fail;
17845 swig_obj[0] = args;
17846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17847 if (!SWIG_IsOK(res1)) {
17848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17849 }
17850 arg1 = reinterpret_cast< wxGrid * >(argp1);
17851 {
17852 PyThreadState* __tstate = wxPyBeginAllowThreads();
17853 (arg1)->SelectAll();
17854 wxPyEndAllowThreads(__tstate);
17855 if (PyErr_Occurred()) SWIG_fail;
17856 }
17857 resultobj = SWIG_Py_Void();
17858 return resultobj;
17859 fail:
17860 return NULL;
17861 }
17862
17863
17864 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17865 PyObject *resultobj = 0;
17866 wxGrid *arg1 = (wxGrid *) 0 ;
17867 bool result;
17868 void *argp1 = 0 ;
17869 int res1 = 0 ;
17870 PyObject *swig_obj[1] ;
17871
17872 if (!args) SWIG_fail;
17873 swig_obj[0] = args;
17874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17875 if (!SWIG_IsOK(res1)) {
17876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17877 }
17878 arg1 = reinterpret_cast< wxGrid * >(argp1);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 result = (bool)(arg1)->IsSelection();
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 {
17886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17887 }
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17895 PyObject *resultobj = 0;
17896 wxGrid *arg1 = (wxGrid *) 0 ;
17897 void *argp1 = 0 ;
17898 int res1 = 0 ;
17899 PyObject *swig_obj[1] ;
17900
17901 if (!args) SWIG_fail;
17902 swig_obj[0] = args;
17903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17904 if (!SWIG_IsOK(res1)) {
17905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17906 }
17907 arg1 = reinterpret_cast< wxGrid * >(argp1);
17908 {
17909 PyThreadState* __tstate = wxPyBeginAllowThreads();
17910 (arg1)->ClearSelection();
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 resultobj = SWIG_Py_Void();
17915 return resultobj;
17916 fail:
17917 return NULL;
17918 }
17919
17920
17921 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj = 0;
17923 wxGrid *arg1 = (wxGrid *) 0 ;
17924 int arg2 ;
17925 int arg3 ;
17926 bool result;
17927 void *argp1 = 0 ;
17928 int res1 = 0 ;
17929 int val2 ;
17930 int ecode2 = 0 ;
17931 int val3 ;
17932 int ecode3 = 0 ;
17933 PyObject * obj0 = 0 ;
17934 PyObject * obj1 = 0 ;
17935 PyObject * obj2 = 0 ;
17936 char * kwnames[] = {
17937 (char *) "self",(char *) "row",(char *) "col", NULL
17938 };
17939
17940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17944 }
17945 arg1 = reinterpret_cast< wxGrid * >(argp1);
17946 ecode2 = SWIG_AsVal_int(obj1, &val2);
17947 if (!SWIG_IsOK(ecode2)) {
17948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17949 }
17950 arg2 = static_cast< int >(val2);
17951 ecode3 = SWIG_AsVal_int(obj2, &val3);
17952 if (!SWIG_IsOK(ecode3)) {
17953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17954 }
17955 arg3 = static_cast< int >(val3);
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 {
17963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17972 PyObject *resultobj = 0;
17973 wxGrid *arg1 = (wxGrid *) 0 ;
17974 wxGridCellCoordsArray result;
17975 void *argp1 = 0 ;
17976 int res1 = 0 ;
17977 PyObject *swig_obj[1] ;
17978
17979 if (!args) SWIG_fail;
17980 swig_obj[0] = args;
17981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17982 if (!SWIG_IsOK(res1)) {
17983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17984 }
17985 arg1 = reinterpret_cast< wxGrid * >(argp1);
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = ((wxGrid const *)arg1)->GetSelectedCells();
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 {
17993 resultobj = wxGridCellCoordsArray_helper(result);
17994 }
17995 return resultobj;
17996 fail:
17997 return NULL;
17998 }
17999
18000
18001 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18002 PyObject *resultobj = 0;
18003 wxGrid *arg1 = (wxGrid *) 0 ;
18004 wxGridCellCoordsArray result;
18005 void *argp1 = 0 ;
18006 int res1 = 0 ;
18007 PyObject *swig_obj[1] ;
18008
18009 if (!args) SWIG_fail;
18010 swig_obj[0] = args;
18011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18012 if (!SWIG_IsOK(res1)) {
18013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18014 }
18015 arg1 = reinterpret_cast< wxGrid * >(argp1);
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 {
18023 resultobj = wxGridCellCoordsArray_helper(result);
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 PyObject *resultobj = 0;
18033 wxGrid *arg1 = (wxGrid *) 0 ;
18034 wxGridCellCoordsArray result;
18035 void *argp1 = 0 ;
18036 int res1 = 0 ;
18037 PyObject *swig_obj[1] ;
18038
18039 if (!args) SWIG_fail;
18040 swig_obj[0] = args;
18041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18042 if (!SWIG_IsOK(res1)) {
18043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18044 }
18045 arg1 = reinterpret_cast< wxGrid * >(argp1);
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = wxGridCellCoordsArray_helper(result);
18054 }
18055 return resultobj;
18056 fail:
18057 return NULL;
18058 }
18059
18060
18061 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18062 PyObject *resultobj = 0;
18063 wxGrid *arg1 = (wxGrid *) 0 ;
18064 wxArrayInt result;
18065 void *argp1 = 0 ;
18066 int res1 = 0 ;
18067 PyObject *swig_obj[1] ;
18068
18069 if (!args) SWIG_fail;
18070 swig_obj[0] = args;
18071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18072 if (!SWIG_IsOK(res1)) {
18073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18074 }
18075 arg1 = reinterpret_cast< wxGrid * >(argp1);
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 result = ((wxGrid const *)arg1)->GetSelectedRows();
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 {
18083 resultobj = wxArrayInt2PyList_helper(result);
18084 }
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18092 PyObject *resultobj = 0;
18093 wxGrid *arg1 = (wxGrid *) 0 ;
18094 wxArrayInt result;
18095 void *argp1 = 0 ;
18096 int res1 = 0 ;
18097 PyObject *swig_obj[1] ;
18098
18099 if (!args) SWIG_fail;
18100 swig_obj[0] = args;
18101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18102 if (!SWIG_IsOK(res1)) {
18103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18104 }
18105 arg1 = reinterpret_cast< wxGrid * >(argp1);
18106 {
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 result = ((wxGrid const *)arg1)->GetSelectedCols();
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 {
18113 resultobj = wxArrayInt2PyList_helper(result);
18114 }
18115 return resultobj;
18116 fail:
18117 return NULL;
18118 }
18119
18120
18121 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18122 PyObject *resultobj = 0;
18123 wxGrid *arg1 = (wxGrid *) 0 ;
18124 int arg2 ;
18125 void *argp1 = 0 ;
18126 int res1 = 0 ;
18127 int val2 ;
18128 int ecode2 = 0 ;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 char * kwnames[] = {
18132 (char *) "self",(char *) "row", NULL
18133 };
18134
18135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18137 if (!SWIG_IsOK(res1)) {
18138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18139 }
18140 arg1 = reinterpret_cast< wxGrid * >(argp1);
18141 ecode2 = SWIG_AsVal_int(obj1, &val2);
18142 if (!SWIG_IsOK(ecode2)) {
18143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18144 }
18145 arg2 = static_cast< int >(val2);
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 (arg1)->DeselectRow(arg2);
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 resultobj = SWIG_Py_Void();
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj = 0;
18161 wxGrid *arg1 = (wxGrid *) 0 ;
18162 int arg2 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 int val2 ;
18166 int ecode2 = 0 ;
18167 PyObject * obj0 = 0 ;
18168 PyObject * obj1 = 0 ;
18169 char * kwnames[] = {
18170 (char *) "self",(char *) "col", NULL
18171 };
18172
18173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18175 if (!SWIG_IsOK(res1)) {
18176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18177 }
18178 arg1 = reinterpret_cast< wxGrid * >(argp1);
18179 ecode2 = SWIG_AsVal_int(obj1, &val2);
18180 if (!SWIG_IsOK(ecode2)) {
18181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18182 }
18183 arg2 = static_cast< int >(val2);
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 (arg1)->DeselectCol(arg2);
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_Py_Void();
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj = 0;
18199 wxGrid *arg1 = (wxGrid *) 0 ;
18200 int arg2 ;
18201 int arg3 ;
18202 void *argp1 = 0 ;
18203 int res1 = 0 ;
18204 int val2 ;
18205 int ecode2 = 0 ;
18206 int val3 ;
18207 int ecode3 = 0 ;
18208 PyObject * obj0 = 0 ;
18209 PyObject * obj1 = 0 ;
18210 PyObject * obj2 = 0 ;
18211 char * kwnames[] = {
18212 (char *) "self",(char *) "row",(char *) "col", NULL
18213 };
18214
18215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18217 if (!SWIG_IsOK(res1)) {
18218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18219 }
18220 arg1 = reinterpret_cast< wxGrid * >(argp1);
18221 ecode2 = SWIG_AsVal_int(obj1, &val2);
18222 if (!SWIG_IsOK(ecode2)) {
18223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18224 }
18225 arg2 = static_cast< int >(val2);
18226 ecode3 = SWIG_AsVal_int(obj2, &val3);
18227 if (!SWIG_IsOK(ecode3)) {
18228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18229 }
18230 arg3 = static_cast< int >(val3);
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 (arg1)->DeselectCell(arg2,arg3);
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 resultobj = SWIG_Py_Void();
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj = 0;
18246 wxGrid *arg1 = (wxGrid *) 0 ;
18247 wxGridCellCoords *arg2 = 0 ;
18248 wxGridCellCoords *arg3 = 0 ;
18249 wxRect result;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 wxGridCellCoords temp2 ;
18253 wxGridCellCoords temp3 ;
18254 PyObject * obj0 = 0 ;
18255 PyObject * obj1 = 0 ;
18256 PyObject * obj2 = 0 ;
18257 char * kwnames[] = {
18258 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18259 };
18260
18261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18263 if (!SWIG_IsOK(res1)) {
18264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18265 }
18266 arg1 = reinterpret_cast< wxGrid * >(argp1);
18267 {
18268 arg2 = &temp2;
18269 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18270 }
18271 {
18272 arg3 = &temp3;
18273 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18274 }
18275 {
18276 PyThreadState* __tstate = wxPyBeginAllowThreads();
18277 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18278 wxPyEndAllowThreads(__tstate);
18279 if (PyErr_Occurred()) SWIG_fail;
18280 }
18281 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18282 return resultobj;
18283 fail:
18284 return NULL;
18285 }
18286
18287
18288 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18289 PyObject *resultobj = 0;
18290 wxGrid *arg1 = (wxGrid *) 0 ;
18291 wxColour result;
18292 void *argp1 = 0 ;
18293 int res1 = 0 ;
18294 PyObject *swig_obj[1] ;
18295
18296 if (!args) SWIG_fail;
18297 swig_obj[0] = args;
18298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18299 if (!SWIG_IsOK(res1)) {
18300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18301 }
18302 arg1 = reinterpret_cast< wxGrid * >(argp1);
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18317 PyObject *resultobj = 0;
18318 wxGrid *arg1 = (wxGrid *) 0 ;
18319 wxColour result;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 PyObject *swig_obj[1] ;
18323
18324 if (!args) SWIG_fail;
18325 swig_obj[0] = args;
18326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18327 if (!SWIG_IsOK(res1)) {
18328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18329 }
18330 arg1 = reinterpret_cast< wxGrid * >(argp1);
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj = 0;
18346 wxGrid *arg1 = (wxGrid *) 0 ;
18347 wxColour *arg2 = 0 ;
18348 void *argp1 = 0 ;
18349 int res1 = 0 ;
18350 wxColour temp2 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "c", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18361 }
18362 arg1 = reinterpret_cast< wxGrid * >(argp1);
18363 {
18364 arg2 = &temp2;
18365 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18366 }
18367 {
18368 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18370 wxPyEndAllowThreads(__tstate);
18371 if (PyErr_Occurred()) SWIG_fail;
18372 }
18373 resultobj = SWIG_Py_Void();
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj = 0;
18382 wxGrid *arg1 = (wxGrid *) 0 ;
18383 wxColour *arg2 = 0 ;
18384 void *argp1 = 0 ;
18385 int res1 = 0 ;
18386 wxColour temp2 ;
18387 PyObject * obj0 = 0 ;
18388 PyObject * obj1 = 0 ;
18389 char * kwnames[] = {
18390 (char *) "self",(char *) "c", NULL
18391 };
18392
18393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18395 if (!SWIG_IsOK(res1)) {
18396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18397 }
18398 arg1 = reinterpret_cast< wxGrid * >(argp1);
18399 {
18400 arg2 = &temp2;
18401 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18402 }
18403 {
18404 PyThreadState* __tstate = wxPyBeginAllowThreads();
18405 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 resultobj = SWIG_Py_Void();
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18417 PyObject *resultobj = 0;
18418 wxGrid *arg1 = (wxGrid *) 0 ;
18419 wxString *arg2 = 0 ;
18420 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18421 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18422 void *argp1 = 0 ;
18423 int res1 = 0 ;
18424 bool temp2 = false ;
18425 void *argp3 = 0 ;
18426 int res3 = 0 ;
18427 void *argp4 = 0 ;
18428 int res4 = 0 ;
18429 PyObject * obj0 = 0 ;
18430 PyObject * obj1 = 0 ;
18431 PyObject * obj2 = 0 ;
18432 PyObject * obj3 = 0 ;
18433 char * kwnames[] = {
18434 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18435 };
18436
18437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18439 if (!SWIG_IsOK(res1)) {
18440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18441 }
18442 arg1 = reinterpret_cast< wxGrid * >(argp1);
18443 {
18444 arg2 = wxString_in_helper(obj1);
18445 if (arg2 == NULL) SWIG_fail;
18446 temp2 = true;
18447 }
18448 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18449 if (!SWIG_IsOK(res3)) {
18450 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18451 }
18452 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18453 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18454 if (!SWIG_IsOK(res4)) {
18455 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18456 }
18457 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 resultobj = SWIG_Py_Void();
18465 {
18466 if (temp2)
18467 delete arg2;
18468 }
18469 return resultobj;
18470 fail:
18471 {
18472 if (temp2)
18473 delete arg2;
18474 }
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj = 0;
18481 wxGrid *arg1 = (wxGrid *) 0 ;
18482 int arg2 ;
18483 int arg3 ;
18484 wxGridCellEditor *result = 0 ;
18485 void *argp1 = 0 ;
18486 int res1 = 0 ;
18487 int val2 ;
18488 int ecode2 = 0 ;
18489 int val3 ;
18490 int ecode3 = 0 ;
18491 PyObject * obj0 = 0 ;
18492 PyObject * obj1 = 0 ;
18493 PyObject * obj2 = 0 ;
18494 char * kwnames[] = {
18495 (char *) "self",(char *) "row",(char *) "col", NULL
18496 };
18497
18498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18500 if (!SWIG_IsOK(res1)) {
18501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18502 }
18503 arg1 = reinterpret_cast< wxGrid * >(argp1);
18504 ecode2 = SWIG_AsVal_int(obj1, &val2);
18505 if (!SWIG_IsOK(ecode2)) {
18506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18507 }
18508 arg2 = static_cast< int >(val2);
18509 ecode3 = SWIG_AsVal_int(obj2, &val3);
18510 if (!SWIG_IsOK(ecode3)) {
18511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18512 }
18513 arg3 = static_cast< int >(val3);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj = 0;
18531 wxGrid *arg1 = (wxGrid *) 0 ;
18532 int arg2 ;
18533 int arg3 ;
18534 wxGridCellRenderer *result = 0 ;
18535 void *argp1 = 0 ;
18536 int res1 = 0 ;
18537 int val2 ;
18538 int ecode2 = 0 ;
18539 int val3 ;
18540 int ecode3 = 0 ;
18541 PyObject * obj0 = 0 ;
18542 PyObject * obj1 = 0 ;
18543 PyObject * obj2 = 0 ;
18544 char * kwnames[] = {
18545 (char *) "self",(char *) "row",(char *) "col", NULL
18546 };
18547
18548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18550 if (!SWIG_IsOK(res1)) {
18551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18552 }
18553 arg1 = reinterpret_cast< wxGrid * >(argp1);
18554 ecode2 = SWIG_AsVal_int(obj1, &val2);
18555 if (!SWIG_IsOK(ecode2)) {
18556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18557 }
18558 arg2 = static_cast< int >(val2);
18559 ecode3 = SWIG_AsVal_int(obj2, &val3);
18560 if (!SWIG_IsOK(ecode3)) {
18561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18562 }
18563 arg3 = static_cast< int >(val3);
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 {
18571 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18572 }
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18580 PyObject *resultobj = 0;
18581 wxGrid *arg1 = (wxGrid *) 0 ;
18582 wxString *arg2 = 0 ;
18583 wxGridCellEditor *result = 0 ;
18584 void *argp1 = 0 ;
18585 int res1 = 0 ;
18586 bool temp2 = false ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char * kwnames[] = {
18590 (char *) "self",(char *) "typeName", NULL
18591 };
18592
18593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18595 if (!SWIG_IsOK(res1)) {
18596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18597 }
18598 arg1 = reinterpret_cast< wxGrid * >(argp1);
18599 {
18600 arg2 = wxString_in_helper(obj1);
18601 if (arg2 == NULL) SWIG_fail;
18602 temp2 = true;
18603 }
18604 {
18605 PyThreadState* __tstate = wxPyBeginAllowThreads();
18606 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18607 wxPyEndAllowThreads(__tstate);
18608 if (PyErr_Occurred()) SWIG_fail;
18609 }
18610 {
18611 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18612 }
18613 {
18614 if (temp2)
18615 delete arg2;
18616 }
18617 return resultobj;
18618 fail:
18619 {
18620 if (temp2)
18621 delete arg2;
18622 }
18623 return NULL;
18624 }
18625
18626
18627 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj = 0;
18629 wxGrid *arg1 = (wxGrid *) 0 ;
18630 wxString *arg2 = 0 ;
18631 wxGridCellRenderer *result = 0 ;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 bool temp2 = false ;
18635 PyObject * obj0 = 0 ;
18636 PyObject * obj1 = 0 ;
18637 char * kwnames[] = {
18638 (char *) "self",(char *) "typeName", NULL
18639 };
18640
18641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18643 if (!SWIG_IsOK(res1)) {
18644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18645 }
18646 arg1 = reinterpret_cast< wxGrid * >(argp1);
18647 {
18648 arg2 = wxString_in_helper(obj1);
18649 if (arg2 == NULL) SWIG_fail;
18650 temp2 = true;
18651 }
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 {
18659 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18660 }
18661 {
18662 if (temp2)
18663 delete arg2;
18664 }
18665 return resultobj;
18666 fail:
18667 {
18668 if (temp2)
18669 delete arg2;
18670 }
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj = 0;
18677 wxGrid *arg1 = (wxGrid *) 0 ;
18678 int arg2 ;
18679 int arg3 ;
18680 void *argp1 = 0 ;
18681 int res1 = 0 ;
18682 int val2 ;
18683 int ecode2 = 0 ;
18684 int val3 ;
18685 int ecode3 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 PyObject * obj2 = 0 ;
18689 char * kwnames[] = {
18690 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18691 };
18692
18693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18695 if (!SWIG_IsOK(res1)) {
18696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18697 }
18698 arg1 = reinterpret_cast< wxGrid * >(argp1);
18699 ecode2 = SWIG_AsVal_int(obj1, &val2);
18700 if (!SWIG_IsOK(ecode2)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18702 }
18703 arg2 = static_cast< int >(val2);
18704 ecode3 = SWIG_AsVal_int(obj2, &val3);
18705 if (!SWIG_IsOK(ecode3)) {
18706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18707 }
18708 arg3 = static_cast< int >(val3);
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 (arg1)->SetMargins(arg2,arg3);
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 resultobj = SWIG_Py_Void();
18716 return resultobj;
18717 fail:
18718 return NULL;
18719 }
18720
18721
18722 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18723 PyObject *resultobj = 0;
18724 wxGrid *arg1 = (wxGrid *) 0 ;
18725 wxWindow *result = 0 ;
18726 void *argp1 = 0 ;
18727 int res1 = 0 ;
18728 PyObject *swig_obj[1] ;
18729
18730 if (!args) SWIG_fail;
18731 swig_obj[0] = args;
18732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18733 if (!SWIG_IsOK(res1)) {
18734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18735 }
18736 arg1 = reinterpret_cast< wxGrid * >(argp1);
18737 {
18738 PyThreadState* __tstate = wxPyBeginAllowThreads();
18739 result = (wxWindow *)(arg1)->GetGridWindow();
18740 wxPyEndAllowThreads(__tstate);
18741 if (PyErr_Occurred()) SWIG_fail;
18742 }
18743 {
18744 resultobj = wxPyMake_wxObject(result, 0);
18745 }
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18753 PyObject *resultobj = 0;
18754 wxGrid *arg1 = (wxGrid *) 0 ;
18755 wxWindow *result = 0 ;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 PyObject *swig_obj[1] ;
18759
18760 if (!args) SWIG_fail;
18761 swig_obj[0] = args;
18762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18763 if (!SWIG_IsOK(res1)) {
18764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18765 }
18766 arg1 = reinterpret_cast< wxGrid * >(argp1);
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18770 wxPyEndAllowThreads(__tstate);
18771 if (PyErr_Occurred()) SWIG_fail;
18772 }
18773 {
18774 resultobj = wxPyMake_wxObject(result, 0);
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18783 PyObject *resultobj = 0;
18784 wxGrid *arg1 = (wxGrid *) 0 ;
18785 wxWindow *result = 0 ;
18786 void *argp1 = 0 ;
18787 int res1 = 0 ;
18788 PyObject *swig_obj[1] ;
18789
18790 if (!args) SWIG_fail;
18791 swig_obj[0] = args;
18792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18793 if (!SWIG_IsOK(res1)) {
18794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18795 }
18796 arg1 = reinterpret_cast< wxGrid * >(argp1);
18797 {
18798 PyThreadState* __tstate = wxPyBeginAllowThreads();
18799 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18800 wxPyEndAllowThreads(__tstate);
18801 if (PyErr_Occurred()) SWIG_fail;
18802 }
18803 {
18804 resultobj = wxPyMake_wxObject(result, 0);
18805 }
18806 return resultobj;
18807 fail:
18808 return NULL;
18809 }
18810
18811
18812 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18813 PyObject *resultobj = 0;
18814 wxGrid *arg1 = (wxGrid *) 0 ;
18815 wxWindow *result = 0 ;
18816 void *argp1 = 0 ;
18817 int res1 = 0 ;
18818 PyObject *swig_obj[1] ;
18819
18820 if (!args) SWIG_fail;
18821 swig_obj[0] = args;
18822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18823 if (!SWIG_IsOK(res1)) {
18824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18825 }
18826 arg1 = reinterpret_cast< wxGrid * >(argp1);
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 {
18834 resultobj = wxPyMake_wxObject(result, 0);
18835 }
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 wxGrid *arg1 = (wxGrid *) 0 ;
18845 int arg2 ;
18846 void *argp1 = 0 ;
18847 int res1 = 0 ;
18848 int val2 ;
18849 int ecode2 = 0 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char * kwnames[] = {
18853 (char *) "self",(char *) "x", NULL
18854 };
18855
18856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18860 }
18861 arg1 = reinterpret_cast< wxGrid * >(argp1);
18862 ecode2 = SWIG_AsVal_int(obj1, &val2);
18863 if (!SWIG_IsOK(ecode2)) {
18864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18865 }
18866 arg2 = static_cast< int >(val2);
18867 {
18868 PyThreadState* __tstate = wxPyBeginAllowThreads();
18869 (arg1)->SetScrollLineX(arg2);
18870 wxPyEndAllowThreads(__tstate);
18871 if (PyErr_Occurred()) SWIG_fail;
18872 }
18873 resultobj = SWIG_Py_Void();
18874 return resultobj;
18875 fail:
18876 return NULL;
18877 }
18878
18879
18880 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18881 PyObject *resultobj = 0;
18882 wxGrid *arg1 = (wxGrid *) 0 ;
18883 int arg2 ;
18884 void *argp1 = 0 ;
18885 int res1 = 0 ;
18886 int val2 ;
18887 int ecode2 = 0 ;
18888 PyObject * obj0 = 0 ;
18889 PyObject * obj1 = 0 ;
18890 char * kwnames[] = {
18891 (char *) "self",(char *) "y", NULL
18892 };
18893
18894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18896 if (!SWIG_IsOK(res1)) {
18897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18898 }
18899 arg1 = reinterpret_cast< wxGrid * >(argp1);
18900 ecode2 = SWIG_AsVal_int(obj1, &val2);
18901 if (!SWIG_IsOK(ecode2)) {
18902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18903 }
18904 arg2 = static_cast< int >(val2);
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 (arg1)->SetScrollLineY(arg2);
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 resultobj = SWIG_Py_Void();
18912 return resultobj;
18913 fail:
18914 return NULL;
18915 }
18916
18917
18918 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18919 PyObject *resultobj = 0;
18920 wxGrid *arg1 = (wxGrid *) 0 ;
18921 int result;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 PyObject *swig_obj[1] ;
18925
18926 if (!args) SWIG_fail;
18927 swig_obj[0] = args;
18928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18929 if (!SWIG_IsOK(res1)) {
18930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18931 }
18932 arg1 = reinterpret_cast< wxGrid * >(argp1);
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18936 wxPyEndAllowThreads(__tstate);
18937 if (PyErr_Occurred()) SWIG_fail;
18938 }
18939 resultobj = SWIG_From_int(static_cast< int >(result));
18940 return resultobj;
18941 fail:
18942 return NULL;
18943 }
18944
18945
18946 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18947 PyObject *resultobj = 0;
18948 wxGrid *arg1 = (wxGrid *) 0 ;
18949 int result;
18950 void *argp1 = 0 ;
18951 int res1 = 0 ;
18952 PyObject *swig_obj[1] ;
18953
18954 if (!args) SWIG_fail;
18955 swig_obj[0] = args;
18956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18959 }
18960 arg1 = reinterpret_cast< wxGrid * >(argp1);
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = SWIG_From_int(static_cast< int >(result));
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj = 0;
18976 wxGrid *arg1 = (wxGrid *) 0 ;
18977 int arg2 ;
18978 int result;
18979 void *argp1 = 0 ;
18980 int res1 = 0 ;
18981 int val2 ;
18982 int ecode2 = 0 ;
18983 PyObject * obj0 = 0 ;
18984 PyObject * obj1 = 0 ;
18985 char * kwnames[] = {
18986 (char *) "self",(char *) "x", NULL
18987 };
18988
18989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18991 if (!SWIG_IsOK(res1)) {
18992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18993 }
18994 arg1 = reinterpret_cast< wxGrid * >(argp1);
18995 ecode2 = SWIG_AsVal_int(obj1, &val2);
18996 if (!SWIG_IsOK(ecode2)) {
18997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18998 }
18999 arg2 = static_cast< int >(val2);
19000 {
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19003 wxPyEndAllowThreads(__tstate);
19004 if (PyErr_Occurred()) SWIG_fail;
19005 }
19006 resultobj = SWIG_From_int(static_cast< int >(result));
19007 return resultobj;
19008 fail:
19009 return NULL;
19010 }
19011
19012
19013 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19014 PyObject *resultobj = 0;
19015 wxGrid *arg1 = (wxGrid *) 0 ;
19016 int arg2 ;
19017 int result;
19018 void *argp1 = 0 ;
19019 int res1 = 0 ;
19020 int val2 ;
19021 int ecode2 = 0 ;
19022 PyObject * obj0 = 0 ;
19023 PyObject * obj1 = 0 ;
19024 char * kwnames[] = {
19025 (char *) "self",(char *) "y", NULL
19026 };
19027
19028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19030 if (!SWIG_IsOK(res1)) {
19031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19032 }
19033 arg1 = reinterpret_cast< wxGrid * >(argp1);
19034 ecode2 = SWIG_AsVal_int(obj1, &val2);
19035 if (!SWIG_IsOK(ecode2)) {
19036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19037 }
19038 arg2 = static_cast< int >(val2);
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = SWIG_From_int(static_cast< int >(result));
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19055 SwigValueWrapper<wxVisualAttributes > result;
19056 int val1 ;
19057 int ecode1 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 char * kwnames[] = {
19060 (char *) "variant", NULL
19061 };
19062
19063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19064 if (obj0) {
19065 ecode1 = SWIG_AsVal_int(obj0, &val1);
19066 if (!SWIG_IsOK(ecode1)) {
19067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19068 }
19069 arg1 = static_cast< wxWindowVariant >(val1);
19070 }
19071 {
19072 if (!wxPyCheckForApp()) SWIG_fail;
19073 PyThreadState* __tstate = wxPyBeginAllowThreads();
19074 result = wxGrid::GetClassDefaultAttributes(arg1);
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19086 PyObject *obj;
19087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19088 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19089 return SWIG_Py_Void();
19090 }
19091
19092 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19093 return SWIG_Python_InitShadowInstance(args);
19094 }
19095
19096 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj = 0;
19098 int arg1 ;
19099 wxEventType arg2 ;
19100 wxGrid *arg3 = (wxGrid *) 0 ;
19101 int arg4 = (int) -1 ;
19102 int arg5 = (int) -1 ;
19103 int arg6 = (int) -1 ;
19104 int arg7 = (int) -1 ;
19105 bool arg8 = (bool) true ;
19106 bool arg9 = (bool) false ;
19107 bool arg10 = (bool) false ;
19108 bool arg11 = (bool) false ;
19109 bool arg12 = (bool) false ;
19110 wxGridEvent *result = 0 ;
19111 int val1 ;
19112 int ecode1 = 0 ;
19113 int val2 ;
19114 int ecode2 = 0 ;
19115 void *argp3 = 0 ;
19116 int res3 = 0 ;
19117 int val4 ;
19118 int ecode4 = 0 ;
19119 int val5 ;
19120 int ecode5 = 0 ;
19121 int val6 ;
19122 int ecode6 = 0 ;
19123 int val7 ;
19124 int ecode7 = 0 ;
19125 bool val8 ;
19126 int ecode8 = 0 ;
19127 bool val9 ;
19128 int ecode9 = 0 ;
19129 bool val10 ;
19130 int ecode10 = 0 ;
19131 bool val11 ;
19132 int ecode11 = 0 ;
19133 bool val12 ;
19134 int ecode12 = 0 ;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 PyObject * obj2 = 0 ;
19138 PyObject * obj3 = 0 ;
19139 PyObject * obj4 = 0 ;
19140 PyObject * obj5 = 0 ;
19141 PyObject * obj6 = 0 ;
19142 PyObject * obj7 = 0 ;
19143 PyObject * obj8 = 0 ;
19144 PyObject * obj9 = 0 ;
19145 PyObject * obj10 = 0 ;
19146 PyObject * obj11 = 0 ;
19147 char * kwnames[] = {
19148 (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
19149 };
19150
19151 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;
19152 ecode1 = SWIG_AsVal_int(obj0, &val1);
19153 if (!SWIG_IsOK(ecode1)) {
19154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19155 }
19156 arg1 = static_cast< int >(val1);
19157 ecode2 = SWIG_AsVal_int(obj1, &val2);
19158 if (!SWIG_IsOK(ecode2)) {
19159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19160 }
19161 arg2 = static_cast< wxEventType >(val2);
19162 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19163 if (!SWIG_IsOK(res3)) {
19164 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19165 }
19166 arg3 = reinterpret_cast< wxGrid * >(argp3);
19167 if (obj3) {
19168 ecode4 = SWIG_AsVal_int(obj3, &val4);
19169 if (!SWIG_IsOK(ecode4)) {
19170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19171 }
19172 arg4 = static_cast< int >(val4);
19173 }
19174 if (obj4) {
19175 ecode5 = SWIG_AsVal_int(obj4, &val5);
19176 if (!SWIG_IsOK(ecode5)) {
19177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19178 }
19179 arg5 = static_cast< int >(val5);
19180 }
19181 if (obj5) {
19182 ecode6 = SWIG_AsVal_int(obj5, &val6);
19183 if (!SWIG_IsOK(ecode6)) {
19184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19185 }
19186 arg6 = static_cast< int >(val6);
19187 }
19188 if (obj6) {
19189 ecode7 = SWIG_AsVal_int(obj6, &val7);
19190 if (!SWIG_IsOK(ecode7)) {
19191 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19192 }
19193 arg7 = static_cast< int >(val7);
19194 }
19195 if (obj7) {
19196 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19197 if (!SWIG_IsOK(ecode8)) {
19198 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19199 }
19200 arg8 = static_cast< bool >(val8);
19201 }
19202 if (obj8) {
19203 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19204 if (!SWIG_IsOK(ecode9)) {
19205 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19206 }
19207 arg9 = static_cast< bool >(val9);
19208 }
19209 if (obj9) {
19210 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19211 if (!SWIG_IsOK(ecode10)) {
19212 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19213 }
19214 arg10 = static_cast< bool >(val10);
19215 }
19216 if (obj10) {
19217 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19218 if (!SWIG_IsOK(ecode11)) {
19219 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19220 }
19221 arg11 = static_cast< bool >(val11);
19222 }
19223 if (obj11) {
19224 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19225 if (!SWIG_IsOK(ecode12)) {
19226 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19227 }
19228 arg12 = static_cast< bool >(val12);
19229 }
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19244 PyObject *resultobj = 0;
19245 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19246 int result;
19247 void *argp1 = 0 ;
19248 int res1 = 0 ;
19249 PyObject *swig_obj[1] ;
19250
19251 if (!args) SWIG_fail;
19252 swig_obj[0] = args;
19253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19254 if (!SWIG_IsOK(res1)) {
19255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19256 }
19257 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 result = (int)(arg1)->GetRow();
19261 wxPyEndAllowThreads(__tstate);
19262 if (PyErr_Occurred()) SWIG_fail;
19263 }
19264 resultobj = SWIG_From_int(static_cast< int >(result));
19265 return resultobj;
19266 fail:
19267 return NULL;
19268 }
19269
19270
19271 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19272 PyObject *resultobj = 0;
19273 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19274 int result;
19275 void *argp1 = 0 ;
19276 int res1 = 0 ;
19277 PyObject *swig_obj[1] ;
19278
19279 if (!args) SWIG_fail;
19280 swig_obj[0] = args;
19281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19282 if (!SWIG_IsOK(res1)) {
19283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19284 }
19285 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (int)(arg1)->GetCol();
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 resultobj = SWIG_From_int(static_cast< int >(result));
19293 return resultobj;
19294 fail:
19295 return NULL;
19296 }
19297
19298
19299 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19300 PyObject *resultobj = 0;
19301 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19302 wxPoint result;
19303 void *argp1 = 0 ;
19304 int res1 = 0 ;
19305 PyObject *swig_obj[1] ;
19306
19307 if (!args) SWIG_fail;
19308 swig_obj[0] = args;
19309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19310 if (!SWIG_IsOK(res1)) {
19311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19312 }
19313 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = (arg1)->GetPosition();
19317 wxPyEndAllowThreads(__tstate);
19318 if (PyErr_Occurred()) SWIG_fail;
19319 }
19320 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19321 return resultobj;
19322 fail:
19323 return NULL;
19324 }
19325
19326
19327 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19328 PyObject *resultobj = 0;
19329 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19330 bool result;
19331 void *argp1 = 0 ;
19332 int res1 = 0 ;
19333 PyObject *swig_obj[1] ;
19334
19335 if (!args) SWIG_fail;
19336 swig_obj[0] = args;
19337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19338 if (!SWIG_IsOK(res1)) {
19339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19340 }
19341 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19342 {
19343 PyThreadState* __tstate = wxPyBeginAllowThreads();
19344 result = (bool)(arg1)->Selecting();
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 {
19349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19350 }
19351 return resultobj;
19352 fail:
19353 return NULL;
19354 }
19355
19356
19357 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19358 PyObject *resultobj = 0;
19359 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19360 bool result;
19361 void *argp1 = 0 ;
19362 int res1 = 0 ;
19363 PyObject *swig_obj[1] ;
19364
19365 if (!args) SWIG_fail;
19366 swig_obj[0] = args;
19367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19368 if (!SWIG_IsOK(res1)) {
19369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19370 }
19371 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 result = (bool)(arg1)->ControlDown();
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 {
19379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19380 }
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19388 PyObject *resultobj = 0;
19389 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19390 bool result;
19391 void *argp1 = 0 ;
19392 int res1 = 0 ;
19393 PyObject *swig_obj[1] ;
19394
19395 if (!args) SWIG_fail;
19396 swig_obj[0] = args;
19397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19398 if (!SWIG_IsOK(res1)) {
19399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19400 }
19401 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19402 {
19403 PyThreadState* __tstate = wxPyBeginAllowThreads();
19404 result = (bool)(arg1)->MetaDown();
19405 wxPyEndAllowThreads(__tstate);
19406 if (PyErr_Occurred()) SWIG_fail;
19407 }
19408 {
19409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19410 }
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19418 PyObject *resultobj = 0;
19419 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19420 bool result;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 PyObject *swig_obj[1] ;
19424
19425 if (!args) SWIG_fail;
19426 swig_obj[0] = args;
19427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19428 if (!SWIG_IsOK(res1)) {
19429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19430 }
19431 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (bool)(arg1)->ShiftDown();
19435 wxPyEndAllowThreads(__tstate);
19436 if (PyErr_Occurred()) SWIG_fail;
19437 }
19438 {
19439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19440 }
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19448 PyObject *resultobj = 0;
19449 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19450 bool result;
19451 void *argp1 = 0 ;
19452 int res1 = 0 ;
19453 PyObject *swig_obj[1] ;
19454
19455 if (!args) SWIG_fail;
19456 swig_obj[0] = args;
19457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19458 if (!SWIG_IsOK(res1)) {
19459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19460 }
19461 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (bool)(arg1)->AltDown();
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 {
19469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19470 }
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19478 PyObject *resultobj = 0;
19479 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19480 bool result;
19481 void *argp1 = 0 ;
19482 int res1 = 0 ;
19483 PyObject *swig_obj[1] ;
19484
19485 if (!args) SWIG_fail;
19486 swig_obj[0] = args;
19487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19488 if (!SWIG_IsOK(res1)) {
19489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19490 }
19491 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = (bool)(arg1)->CmdDown();
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 {
19499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19500 }
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19508 PyObject *obj;
19509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19510 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19511 return SWIG_Py_Void();
19512 }
19513
19514 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 return SWIG_Python_InitShadowInstance(args);
19516 }
19517
19518 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 int arg1 ;
19521 wxEventType arg2 ;
19522 wxGrid *arg3 = (wxGrid *) 0 ;
19523 int arg4 = (int) -1 ;
19524 int arg5 = (int) -1 ;
19525 int arg6 = (int) -1 ;
19526 bool arg7 = (bool) false ;
19527 bool arg8 = (bool) false ;
19528 bool arg9 = (bool) false ;
19529 bool arg10 = (bool) false ;
19530 wxGridSizeEvent *result = 0 ;
19531 int val1 ;
19532 int ecode1 = 0 ;
19533 int val2 ;
19534 int ecode2 = 0 ;
19535 void *argp3 = 0 ;
19536 int res3 = 0 ;
19537 int val4 ;
19538 int ecode4 = 0 ;
19539 int val5 ;
19540 int ecode5 = 0 ;
19541 int val6 ;
19542 int ecode6 = 0 ;
19543 bool val7 ;
19544 int ecode7 = 0 ;
19545 bool val8 ;
19546 int ecode8 = 0 ;
19547 bool val9 ;
19548 int ecode9 = 0 ;
19549 bool val10 ;
19550 int ecode10 = 0 ;
19551 PyObject * obj0 = 0 ;
19552 PyObject * obj1 = 0 ;
19553 PyObject * obj2 = 0 ;
19554 PyObject * obj3 = 0 ;
19555 PyObject * obj4 = 0 ;
19556 PyObject * obj5 = 0 ;
19557 PyObject * obj6 = 0 ;
19558 PyObject * obj7 = 0 ;
19559 PyObject * obj8 = 0 ;
19560 PyObject * obj9 = 0 ;
19561 char * kwnames[] = {
19562 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19563 };
19564
19565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19566 ecode1 = SWIG_AsVal_int(obj0, &val1);
19567 if (!SWIG_IsOK(ecode1)) {
19568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19569 }
19570 arg1 = static_cast< int >(val1);
19571 ecode2 = SWIG_AsVal_int(obj1, &val2);
19572 if (!SWIG_IsOK(ecode2)) {
19573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19574 }
19575 arg2 = static_cast< wxEventType >(val2);
19576 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19577 if (!SWIG_IsOK(res3)) {
19578 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19579 }
19580 arg3 = reinterpret_cast< wxGrid * >(argp3);
19581 if (obj3) {
19582 ecode4 = SWIG_AsVal_int(obj3, &val4);
19583 if (!SWIG_IsOK(ecode4)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19585 }
19586 arg4 = static_cast< int >(val4);
19587 }
19588 if (obj4) {
19589 ecode5 = SWIG_AsVal_int(obj4, &val5);
19590 if (!SWIG_IsOK(ecode5)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19592 }
19593 arg5 = static_cast< int >(val5);
19594 }
19595 if (obj5) {
19596 ecode6 = SWIG_AsVal_int(obj5, &val6);
19597 if (!SWIG_IsOK(ecode6)) {
19598 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19599 }
19600 arg6 = static_cast< int >(val6);
19601 }
19602 if (obj6) {
19603 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19604 if (!SWIG_IsOK(ecode7)) {
19605 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19606 }
19607 arg7 = static_cast< bool >(val7);
19608 }
19609 if (obj7) {
19610 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19611 if (!SWIG_IsOK(ecode8)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19613 }
19614 arg8 = static_cast< bool >(val8);
19615 }
19616 if (obj8) {
19617 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19618 if (!SWIG_IsOK(ecode9)) {
19619 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19620 }
19621 arg9 = static_cast< bool >(val9);
19622 }
19623 if (obj9) {
19624 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19625 if (!SWIG_IsOK(ecode10)) {
19626 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19627 }
19628 arg10 = static_cast< bool >(val10);
19629 }
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 PyObject *resultobj = 0;
19645 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19646 int result;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 PyObject *swig_obj[1] ;
19650
19651 if (!args) SWIG_fail;
19652 swig_obj[0] = args;
19653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19654 if (!SWIG_IsOK(res1)) {
19655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19656 }
19657 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (int)(arg1)->GetRowOrCol();
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_From_int(static_cast< int >(result));
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 PyObject *resultobj = 0;
19673 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19674 wxPoint result;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 PyObject *swig_obj[1] ;
19678
19679 if (!args) SWIG_fail;
19680 swig_obj[0] = args;
19681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19682 if (!SWIG_IsOK(res1)) {
19683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19684 }
19685 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (arg1)->GetPosition();
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19700 PyObject *resultobj = 0;
19701 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19702 bool result;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 PyObject *swig_obj[1] ;
19706
19707 if (!args) SWIG_fail;
19708 swig_obj[0] = args;
19709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19710 if (!SWIG_IsOK(res1)) {
19711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19712 }
19713 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (bool)(arg1)->ControlDown();
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 {
19721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19722 }
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19730 PyObject *resultobj = 0;
19731 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19732 bool result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 PyObject *swig_obj[1] ;
19736
19737 if (!args) SWIG_fail;
19738 swig_obj[0] = args;
19739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19740 if (!SWIG_IsOK(res1)) {
19741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19742 }
19743 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (bool)(arg1)->MetaDown();
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 {
19751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19752 }
19753 return resultobj;
19754 fail:
19755 return NULL;
19756 }
19757
19758
19759 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19760 PyObject *resultobj = 0;
19761 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19762 bool result;
19763 void *argp1 = 0 ;
19764 int res1 = 0 ;
19765 PyObject *swig_obj[1] ;
19766
19767 if (!args) SWIG_fail;
19768 swig_obj[0] = args;
19769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19770 if (!SWIG_IsOK(res1)) {
19771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19772 }
19773 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19774 {
19775 PyThreadState* __tstate = wxPyBeginAllowThreads();
19776 result = (bool)(arg1)->ShiftDown();
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 {
19781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19782 }
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19790 PyObject *resultobj = 0;
19791 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19792 bool result;
19793 void *argp1 = 0 ;
19794 int res1 = 0 ;
19795 PyObject *swig_obj[1] ;
19796
19797 if (!args) SWIG_fail;
19798 swig_obj[0] = args;
19799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19804 {
19805 PyThreadState* __tstate = wxPyBeginAllowThreads();
19806 result = (bool)(arg1)->AltDown();
19807 wxPyEndAllowThreads(__tstate);
19808 if (PyErr_Occurred()) SWIG_fail;
19809 }
19810 {
19811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19812 }
19813 return resultobj;
19814 fail:
19815 return NULL;
19816 }
19817
19818
19819 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19820 PyObject *resultobj = 0;
19821 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19822 bool result;
19823 void *argp1 = 0 ;
19824 int res1 = 0 ;
19825 PyObject *swig_obj[1] ;
19826
19827 if (!args) SWIG_fail;
19828 swig_obj[0] = args;
19829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19830 if (!SWIG_IsOK(res1)) {
19831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19832 }
19833 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 result = (bool)(arg1)->CmdDown();
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19850 PyObject *obj;
19851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19852 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19853 return SWIG_Py_Void();
19854 }
19855
19856 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19857 return SWIG_Python_InitShadowInstance(args);
19858 }
19859
19860 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19861 PyObject *resultobj = 0;
19862 int arg1 ;
19863 wxEventType arg2 ;
19864 wxGrid *arg3 = (wxGrid *) 0 ;
19865 wxGridCellCoords *arg4 = 0 ;
19866 wxGridCellCoords *arg5 = 0 ;
19867 bool arg6 = (bool) true ;
19868 bool arg7 = (bool) false ;
19869 bool arg8 = (bool) false ;
19870 bool arg9 = (bool) false ;
19871 bool arg10 = (bool) false ;
19872 wxGridRangeSelectEvent *result = 0 ;
19873 int val1 ;
19874 int ecode1 = 0 ;
19875 int val2 ;
19876 int ecode2 = 0 ;
19877 void *argp3 = 0 ;
19878 int res3 = 0 ;
19879 wxGridCellCoords temp4 ;
19880 wxGridCellCoords temp5 ;
19881 bool val6 ;
19882 int ecode6 = 0 ;
19883 bool val7 ;
19884 int ecode7 = 0 ;
19885 bool val8 ;
19886 int ecode8 = 0 ;
19887 bool val9 ;
19888 int ecode9 = 0 ;
19889 bool val10 ;
19890 int ecode10 = 0 ;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 PyObject * obj2 = 0 ;
19894 PyObject * obj3 = 0 ;
19895 PyObject * obj4 = 0 ;
19896 PyObject * obj5 = 0 ;
19897 PyObject * obj6 = 0 ;
19898 PyObject * obj7 = 0 ;
19899 PyObject * obj8 = 0 ;
19900 PyObject * obj9 = 0 ;
19901 char * kwnames[] = {
19902 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19903 };
19904
19905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19906 ecode1 = SWIG_AsVal_int(obj0, &val1);
19907 if (!SWIG_IsOK(ecode1)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19909 }
19910 arg1 = static_cast< int >(val1);
19911 ecode2 = SWIG_AsVal_int(obj1, &val2);
19912 if (!SWIG_IsOK(ecode2)) {
19913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19914 }
19915 arg2 = static_cast< wxEventType >(val2);
19916 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19917 if (!SWIG_IsOK(res3)) {
19918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19919 }
19920 arg3 = reinterpret_cast< wxGrid * >(argp3);
19921 {
19922 arg4 = &temp4;
19923 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19924 }
19925 {
19926 arg5 = &temp5;
19927 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19928 }
19929 if (obj5) {
19930 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19931 if (!SWIG_IsOK(ecode6)) {
19932 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19933 }
19934 arg6 = static_cast< bool >(val6);
19935 }
19936 if (obj6) {
19937 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19938 if (!SWIG_IsOK(ecode7)) {
19939 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19940 }
19941 arg7 = static_cast< bool >(val7);
19942 }
19943 if (obj7) {
19944 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19945 if (!SWIG_IsOK(ecode8)) {
19946 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19947 }
19948 arg8 = static_cast< bool >(val8);
19949 }
19950 if (obj8) {
19951 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19952 if (!SWIG_IsOK(ecode9)) {
19953 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19954 }
19955 arg9 = static_cast< bool >(val9);
19956 }
19957 if (obj9) {
19958 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19959 if (!SWIG_IsOK(ecode10)) {
19960 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19961 }
19962 arg10 = static_cast< bool >(val10);
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19971 return resultobj;
19972 fail:
19973 return NULL;
19974 }
19975
19976
19977 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19978 PyObject *resultobj = 0;
19979 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19980 wxGridCellCoords result;
19981 void *argp1 = 0 ;
19982 int res1 = 0 ;
19983 PyObject *swig_obj[1] ;
19984
19985 if (!args) SWIG_fail;
19986 swig_obj[0] = args;
19987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19988 if (!SWIG_IsOK(res1)) {
19989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19990 }
19991 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19992 {
19993 PyThreadState* __tstate = wxPyBeginAllowThreads();
19994 result = (arg1)->GetTopLeftCoords();
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20006 PyObject *resultobj = 0;
20007 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20008 wxGridCellCoords result;
20009 void *argp1 = 0 ;
20010 int res1 = 0 ;
20011 PyObject *swig_obj[1] ;
20012
20013 if (!args) SWIG_fail;
20014 swig_obj[0] = args;
20015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20016 if (!SWIG_IsOK(res1)) {
20017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20018 }
20019 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 result = (arg1)->GetBottomRightCoords();
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20034 PyObject *resultobj = 0;
20035 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20036 int result;
20037 void *argp1 = 0 ;
20038 int res1 = 0 ;
20039 PyObject *swig_obj[1] ;
20040
20041 if (!args) SWIG_fail;
20042 swig_obj[0] = args;
20043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20044 if (!SWIG_IsOK(res1)) {
20045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20046 }
20047 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 result = (int)(arg1)->GetTopRow();
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 resultobj = SWIG_From_int(static_cast< int >(result));
20055 return resultobj;
20056 fail:
20057 return NULL;
20058 }
20059
20060
20061 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20062 PyObject *resultobj = 0;
20063 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20064 int result;
20065 void *argp1 = 0 ;
20066 int res1 = 0 ;
20067 PyObject *swig_obj[1] ;
20068
20069 if (!args) SWIG_fail;
20070 swig_obj[0] = args;
20071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20072 if (!SWIG_IsOK(res1)) {
20073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20074 }
20075 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (int)(arg1)->GetBottomRow();
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 resultobj = SWIG_From_int(static_cast< int >(result));
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20090 PyObject *resultobj = 0;
20091 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20092 int result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 PyObject *swig_obj[1] ;
20096
20097 if (!args) SWIG_fail;
20098 swig_obj[0] = args;
20099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20100 if (!SWIG_IsOK(res1)) {
20101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20102 }
20103 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (int)(arg1)->GetLeftCol();
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 resultobj = SWIG_From_int(static_cast< int >(result));
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20118 PyObject *resultobj = 0;
20119 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20120 int result;
20121 void *argp1 = 0 ;
20122 int res1 = 0 ;
20123 PyObject *swig_obj[1] ;
20124
20125 if (!args) SWIG_fail;
20126 swig_obj[0] = args;
20127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20128 if (!SWIG_IsOK(res1)) {
20129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20130 }
20131 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (int)(arg1)->GetRightCol();
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 resultobj = SWIG_From_int(static_cast< int >(result));
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20146 PyObject *resultobj = 0;
20147 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20148 bool result;
20149 void *argp1 = 0 ;
20150 int res1 = 0 ;
20151 PyObject *swig_obj[1] ;
20152
20153 if (!args) SWIG_fail;
20154 swig_obj[0] = args;
20155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20156 if (!SWIG_IsOK(res1)) {
20157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20158 }
20159 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (bool)(arg1)->Selecting();
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *resultobj = 0;
20177 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20178 bool result;
20179 void *argp1 = 0 ;
20180 int res1 = 0 ;
20181 PyObject *swig_obj[1] ;
20182
20183 if (!args) SWIG_fail;
20184 swig_obj[0] = args;
20185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20186 if (!SWIG_IsOK(res1)) {
20187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20188 }
20189 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (bool)(arg1)->ControlDown();
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20198 }
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *resultobj = 0;
20207 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20208 bool result;
20209 void *argp1 = 0 ;
20210 int res1 = 0 ;
20211 PyObject *swig_obj[1] ;
20212
20213 if (!args) SWIG_fail;
20214 swig_obj[0] = args;
20215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20216 if (!SWIG_IsOK(res1)) {
20217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20218 }
20219 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (bool)(arg1)->MetaDown();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20228 }
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20236 PyObject *resultobj = 0;
20237 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20238 bool result;
20239 void *argp1 = 0 ;
20240 int res1 = 0 ;
20241 PyObject *swig_obj[1] ;
20242
20243 if (!args) SWIG_fail;
20244 swig_obj[0] = args;
20245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20246 if (!SWIG_IsOK(res1)) {
20247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20248 }
20249 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (bool)(arg1)->ShiftDown();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20258 }
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20266 PyObject *resultobj = 0;
20267 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20268 bool result;
20269 void *argp1 = 0 ;
20270 int res1 = 0 ;
20271 PyObject *swig_obj[1] ;
20272
20273 if (!args) SWIG_fail;
20274 swig_obj[0] = args;
20275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20276 if (!SWIG_IsOK(res1)) {
20277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20278 }
20279 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (bool)(arg1)->AltDown();
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 {
20287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20288 }
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 PyObject *resultobj = 0;
20297 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20298 bool result;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 PyObject *swig_obj[1] ;
20302
20303 if (!args) SWIG_fail;
20304 swig_obj[0] = args;
20305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20306 if (!SWIG_IsOK(res1)) {
20307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20308 }
20309 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)(arg1)->CmdDown();
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *obj;
20327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20328 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20329 return SWIG_Py_Void();
20330 }
20331
20332 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 return SWIG_Python_InitShadowInstance(args);
20334 }
20335
20336 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj = 0;
20338 int arg1 ;
20339 wxEventType arg2 ;
20340 wxObject *arg3 = (wxObject *) 0 ;
20341 int arg4 ;
20342 int arg5 ;
20343 wxControl *arg6 = (wxControl *) 0 ;
20344 wxGridEditorCreatedEvent *result = 0 ;
20345 int val1 ;
20346 int ecode1 = 0 ;
20347 int val2 ;
20348 int ecode2 = 0 ;
20349 void *argp3 = 0 ;
20350 int res3 = 0 ;
20351 int val4 ;
20352 int ecode4 = 0 ;
20353 int val5 ;
20354 int ecode5 = 0 ;
20355 void *argp6 = 0 ;
20356 int res6 = 0 ;
20357 PyObject * obj0 = 0 ;
20358 PyObject * obj1 = 0 ;
20359 PyObject * obj2 = 0 ;
20360 PyObject * obj3 = 0 ;
20361 PyObject * obj4 = 0 ;
20362 PyObject * obj5 = 0 ;
20363 char * kwnames[] = {
20364 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20365 };
20366
20367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20368 ecode1 = SWIG_AsVal_int(obj0, &val1);
20369 if (!SWIG_IsOK(ecode1)) {
20370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20371 }
20372 arg1 = static_cast< int >(val1);
20373 ecode2 = SWIG_AsVal_int(obj1, &val2);
20374 if (!SWIG_IsOK(ecode2)) {
20375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20376 }
20377 arg2 = static_cast< wxEventType >(val2);
20378 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20379 if (!SWIG_IsOK(res3)) {
20380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20381 }
20382 arg3 = reinterpret_cast< wxObject * >(argp3);
20383 ecode4 = SWIG_AsVal_int(obj3, &val4);
20384 if (!SWIG_IsOK(ecode4)) {
20385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20386 }
20387 arg4 = static_cast< int >(val4);
20388 ecode5 = SWIG_AsVal_int(obj4, &val5);
20389 if (!SWIG_IsOK(ecode5)) {
20390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20391 }
20392 arg5 = static_cast< int >(val5);
20393 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20394 if (!SWIG_IsOK(res6)) {
20395 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20396 }
20397 arg6 = reinterpret_cast< wxControl * >(argp6);
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 PyObject *resultobj = 0;
20413 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20414 int result;
20415 void *argp1 = 0 ;
20416 int res1 = 0 ;
20417 PyObject *swig_obj[1] ;
20418
20419 if (!args) SWIG_fail;
20420 swig_obj[0] = args;
20421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20422 if (!SWIG_IsOK(res1)) {
20423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20424 }
20425 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20426 {
20427 PyThreadState* __tstate = wxPyBeginAllowThreads();
20428 result = (int)(arg1)->GetRow();
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 resultobj = SWIG_From_int(static_cast< int >(result));
20433 return resultobj;
20434 fail:
20435 return NULL;
20436 }
20437
20438
20439 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20440 PyObject *resultobj = 0;
20441 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20442 int result;
20443 void *argp1 = 0 ;
20444 int res1 = 0 ;
20445 PyObject *swig_obj[1] ;
20446
20447 if (!args) SWIG_fail;
20448 swig_obj[0] = args;
20449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20450 if (!SWIG_IsOK(res1)) {
20451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20452 }
20453 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20454 {
20455 PyThreadState* __tstate = wxPyBeginAllowThreads();
20456 result = (int)(arg1)->GetCol();
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 resultobj = SWIG_From_int(static_cast< int >(result));
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20468 PyObject *resultobj = 0;
20469 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20470 wxControl *result = 0 ;
20471 void *argp1 = 0 ;
20472 int res1 = 0 ;
20473 PyObject *swig_obj[1] ;
20474
20475 if (!args) SWIG_fail;
20476 swig_obj[0] = args;
20477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20478 if (!SWIG_IsOK(res1)) {
20479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20480 }
20481 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (wxControl *)(arg1)->GetControl();
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 {
20489 resultobj = wxPyMake_wxObject(result, 0);
20490 }
20491 return resultobj;
20492 fail:
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20498 PyObject *resultobj = 0;
20499 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20500 int arg2 ;
20501 void *argp1 = 0 ;
20502 int res1 = 0 ;
20503 int val2 ;
20504 int ecode2 = 0 ;
20505 PyObject * obj0 = 0 ;
20506 PyObject * obj1 = 0 ;
20507 char * kwnames[] = {
20508 (char *) "self",(char *) "row", NULL
20509 };
20510
20511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20513 if (!SWIG_IsOK(res1)) {
20514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20515 }
20516 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20517 ecode2 = SWIG_AsVal_int(obj1, &val2);
20518 if (!SWIG_IsOK(ecode2)) {
20519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20520 }
20521 arg2 = static_cast< int >(val2);
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 (arg1)->SetRow(arg2);
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 resultobj = SWIG_Py_Void();
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20536 PyObject *resultobj = 0;
20537 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20538 int arg2 ;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 int val2 ;
20542 int ecode2 = 0 ;
20543 PyObject * obj0 = 0 ;
20544 PyObject * obj1 = 0 ;
20545 char * kwnames[] = {
20546 (char *) "self",(char *) "col", NULL
20547 };
20548
20549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20551 if (!SWIG_IsOK(res1)) {
20552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20553 }
20554 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20555 ecode2 = SWIG_AsVal_int(obj1, &val2);
20556 if (!SWIG_IsOK(ecode2)) {
20557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20558 }
20559 arg2 = static_cast< int >(val2);
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 (arg1)->SetCol(arg2);
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_Py_Void();
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj = 0;
20575 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20576 wxControl *arg2 = (wxControl *) 0 ;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 void *argp2 = 0 ;
20580 int res2 = 0 ;
20581 PyObject * obj0 = 0 ;
20582 PyObject * obj1 = 0 ;
20583 char * kwnames[] = {
20584 (char *) "self",(char *) "ctrl", NULL
20585 };
20586
20587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20589 if (!SWIG_IsOK(res1)) {
20590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20591 }
20592 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20594 if (!SWIG_IsOK(res2)) {
20595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20596 }
20597 arg2 = reinterpret_cast< wxControl * >(argp2);
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 (arg1)->SetControl(arg2);
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_Py_Void();
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20612 PyObject *obj;
20613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20614 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20615 return SWIG_Py_Void();
20616 }
20617
20618 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20619 return SWIG_Python_InitShadowInstance(args);
20620 }
20621
20622 static PyMethodDef SwigMethods[] = {
20623 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20625 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20627 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20628 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20629 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20632 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20633 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20634 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20637 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20638 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20639 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20640 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20641 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20642 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20643 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20644 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20646 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20648 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20650 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20651 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20652 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20653 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20654 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20656 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20657 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20659 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20660 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20661 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20662 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20663 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20664 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20665 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20667 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20672 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20673 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20679 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20681 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20682 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20683 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20686 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20687 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20688 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20689 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20690 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20691 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20693 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20694 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20696 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20697 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20698 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20701 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20702 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20704 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20705 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20707 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20708 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20709 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20710 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20711 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20714 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20715 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20717 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20718 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20729 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20730 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20731 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20732 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20733 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20734 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20735 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20736 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20737 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20738 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20739 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20740 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20741 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20742 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20745 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20746 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20748 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20749 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20750 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20758 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20759 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20760 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20766 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20767 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20768 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20771 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20773 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20774 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20775 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20788 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20799 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20804 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20805 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20807 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20808 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20809 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20811 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20812 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20814 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20816 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20818 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20820 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20822 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20823 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20824 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20826 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20827 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20829 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20834 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20835 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20836 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20838 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20842 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20843 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20844 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20846 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20848 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20858 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20859 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20860 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20861 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20862 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20865 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20866 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20867 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20868 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20869 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20870 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20871 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20872 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20879 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20880 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20888 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20889 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20894 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20895 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20896 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20897 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20898 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20899 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20900 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20901 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20902 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20903 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20906 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20907 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20910 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20911 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20912 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20928 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20929 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20931 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20932 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20934 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20935 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20937 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20938 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20940 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20941 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20951 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20952 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20954 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20956 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20958 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20960 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20962 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20964 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20978 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20985 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20986 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21000 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21004 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21013 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21014 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21015 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21017 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21018 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21019 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21020 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21021 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21026 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21027 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21036 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21037 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21038 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21039 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21042 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21043 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21047 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21048 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21050 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21051 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21052 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21053 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21054 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21055 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21056 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21057 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21058 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21059 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21060 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21062 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21063 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21064 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21065 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21066 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21067 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21068 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21069 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21070 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21072 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21073 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21074 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21075 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21076 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21077 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21078 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21079 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21080 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21081 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21082 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21083 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21084 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21085 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21087 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21088 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21089 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21093 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21094 { NULL, NULL, 0, NULL }
21095 };
21096
21097
21098 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21099
21100 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21101 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21102 }
21103 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21104 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21105 }
21106 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21107 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21108 }
21109 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21110 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21111 }
21112 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21113 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21114 }
21115 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21116 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21117 }
21118 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21119 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21120 }
21121 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21122 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21123 }
21124 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21125 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21126 }
21127 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21128 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21129 }
21130 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21131 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21132 }
21133 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21134 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21135 }
21136 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21137 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21138 }
21139 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21140 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21141 }
21142 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21143 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21144 }
21145 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21146 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21147 }
21148 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21149 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21150 }
21151 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21152 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21153 }
21154 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21155 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21156 }
21157 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21158 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21159 }
21160 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21161 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21162 }
21163 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21164 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21165 }
21166 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21167 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21168 }
21169 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21170 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21171 }
21172 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21173 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21174 }
21175 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21176 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21177 }
21178 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21179 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21180 }
21181 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21182 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21183 }
21184 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21185 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21186 }
21187 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21188 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21189 }
21190 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21191 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21192 }
21193 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21194 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21195 }
21196 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21197 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21198 }
21199 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21200 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21201 }
21202 static void *_p_wxGridTo_p_wxPanel(void *x) {
21203 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21204 }
21205 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21206 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21207 }
21208 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21209 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21210 }
21211 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21212 return (void *)((wxPanel *) ((wxPyPanel *) x));
21213 }
21214 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21215 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21216 }
21217 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21218 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21219 }
21220 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21221 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21222 }
21223 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21224 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21225 }
21226 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21227 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21228 }
21229 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21230 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21231 }
21232 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21233 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21234 }
21235 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21236 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21237 }
21238 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21239 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21240 }
21241 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21242 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21243 }
21244 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21245 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21246 }
21247 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21248 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21249 }
21250 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21251 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21252 }
21253 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21254 return (void *)((wxWindow *) ((wxMenuBar *) x));
21255 }
21256 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21257 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21258 }
21259 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21260 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21261 }
21262 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21263 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21264 }
21265 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21266 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21267 }
21268 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21269 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21270 }
21271 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21272 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21273 }
21274 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21275 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21276 }
21277 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21278 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21279 }
21280 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21281 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21282 }
21283 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21284 return (void *)((wxWindow *) ((wxPanel *) x));
21285 }
21286 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21287 return (void *)((wxWindow *) ((wxStatusBar *) x));
21288 }
21289 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21290 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21291 }
21292 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21293 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21294 }
21295 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21296 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21297 }
21298 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21299 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21300 }
21301 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21302 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21303 }
21304 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21305 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21306 }
21307 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21308 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21309 }
21310 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21311 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21312 }
21313 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21314 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21315 }
21316 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21317 return (void *)((wxWindow *) ((wxSashWindow *) x));
21318 }
21319 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21320 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21321 }
21322 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21323 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21324 }
21325 static void *_p_wxControlTo_p_wxWindow(void *x) {
21326 return (void *)((wxWindow *) ((wxControl *) x));
21327 }
21328 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21329 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21330 }
21331 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21332 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21333 }
21334 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21335 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21336 }
21337 static void *_p_wxGridTo_p_wxWindow(void *x) {
21338 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21339 }
21340 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21341 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21342 }
21343 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21344 return (void *)((wxWindow *) ((wxPyWindow *) x));
21345 }
21346 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21347 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21348 }
21349 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21350 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21351 }
21352 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21353 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21354 }
21355 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21356 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21357 }
21358 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21359 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21360 }
21361 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21362 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21363 }
21364 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21365 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21366 }
21367 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21368 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21369 }
21370 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21371 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21372 }
21373 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21374 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21375 }
21376 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21377 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21378 }
21379 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21380 return (void *)((wxControl *) ((wxControlWithItems *) x));
21381 }
21382 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21383 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21384 }
21385 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21386 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21387 }
21388 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21389 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21390 }
21391 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21392 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21393 }
21394 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21395 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21396 }
21397 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21398 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21399 }
21400 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21401 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21402 }
21403 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21404 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21405 }
21406 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21407 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21408 }
21409 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21410 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21411 }
21412 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21413 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21414 }
21415 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21416 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21417 }
21418 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21419 return (void *)((wxEvent *) ((wxPyEvent *) x));
21420 }
21421 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21422 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21423 }
21424 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21425 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21426 }
21427 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21428 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21429 }
21430 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21431 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21432 }
21433 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21434 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21435 }
21436 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21437 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21438 }
21439 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21440 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21441 }
21442 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21443 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21444 }
21445 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21446 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21447 }
21448 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21449 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21450 }
21451 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21452 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21453 }
21454 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21455 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21456 }
21457 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21458 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21459 }
21460 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21461 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21462 }
21463 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21464 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21465 }
21466 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21467 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21468 }
21469 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21470 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21471 }
21472 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21473 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21474 }
21475 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21476 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21477 }
21478 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21479 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21480 }
21481 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21482 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21483 }
21484 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21485 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21486 }
21487 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21488 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21489 }
21490 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21491 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21492 }
21493 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21494 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21495 }
21496 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21497 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21498 }
21499 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21500 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21501 }
21502 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21503 return (void *)((wxEvent *) ((wxShowEvent *) x));
21504 }
21505 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21506 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21507 }
21508 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21509 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21510 }
21511 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21512 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21513 }
21514 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21515 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21516 }
21517 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21518 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21519 }
21520 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21521 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21522 }
21523 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21524 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21525 }
21526 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21527 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21528 }
21529 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21530 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21531 }
21532 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21533 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21534 }
21535 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21536 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21537 }
21538 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21539 return (void *)((wxObject *) ((wxSizerItem *) x));
21540 }
21541 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21542 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21543 }
21544 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21545 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21546 }
21547 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21548 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21549 }
21550 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21551 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21552 }
21553 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21554 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21555 }
21556 static void *_p_wxSizerTo_p_wxObject(void *x) {
21557 return (void *)((wxObject *) ((wxSizer *) x));
21558 }
21559 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21560 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21561 }
21562 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21564 }
21565 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21566 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21567 }
21568 static void *_p_wxEventTo_p_wxObject(void *x) {
21569 return (void *)((wxObject *) ((wxEvent *) x));
21570 }
21571 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21572 return (void *)((wxObject *) ((wxFontData *) x));
21573 }
21574 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21575 return (void *)((wxObject *) ((wxPrintData *) x));
21576 }
21577 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21578 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21579 }
21580 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21581 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21582 }
21583 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21584 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21585 }
21586 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21587 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21588 }
21589 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21590 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21591 }
21592 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21593 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21594 }
21595 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21596 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21597 }
21598 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21600 }
21601 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21602 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21603 }
21604 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21605 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21606 }
21607 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21608 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21609 }
21610 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21611 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21612 }
21613 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21614 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21615 }
21616 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21617 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21618 }
21619 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21620 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21621 }
21622 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21624 }
21625 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21626 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21627 }
21628 static void *_p_wxControlTo_p_wxObject(void *x) {
21629 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21630 }
21631 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21632 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21633 }
21634 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21636 }
21637 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21638 return (void *)((wxObject *) ((wxFSFile *) x));
21639 }
21640 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21641 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21642 }
21643 static void *_p_wxGridTo_p_wxObject(void *x) {
21644 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21645 }
21646 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21647 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21648 }
21649 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21650 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21651 }
21652 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21653 return (void *)((wxObject *) ((wxColourData *) x));
21654 }
21655 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21656 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21657 }
21658 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21659 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21660 }
21661 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21662 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21663 }
21664 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21665 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21666 }
21667 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21668 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21669 }
21670 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21671 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21672 }
21673 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21675 }
21676 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21677 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21678 }
21679 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21680 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21681 }
21682 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21684 }
21685 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21686 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21687 }
21688 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21689 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21690 }
21691 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21692 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21693 }
21694 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21695 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21696 }
21697 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21698 return (void *)((wxObject *) ((wxPrinter *) x));
21699 }
21700 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21701 return (void *)((wxObject *) ((wxMenuItem *) x));
21702 }
21703 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21704 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21705 }
21706 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21707 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21708 }
21709 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21710 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21711 }
21712 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21713 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21714 }
21715 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21716 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21717 }
21718 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21719 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21720 }
21721 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21722 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21723 }
21724 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21725 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21726 }
21727 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21728 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21729 }
21730 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21731 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21732 }
21733 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21734 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21735 }
21736 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21737 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21738 }
21739 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21740 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21741 }
21742 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21743 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21744 }
21745 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21746 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21747 }
21748 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21749 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21750 }
21751 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21752 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21753 }
21754 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21755 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21756 }
21757 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21758 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21759 }
21760 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21761 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21762 }
21763 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21764 return (void *)((wxObject *) ((wxImageHandler *) x));
21765 }
21766 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21767 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21768 }
21769 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21770 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21771 }
21772 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21773 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21774 }
21775 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21776 return (void *)((wxObject *) ((wxEvtHandler *) x));
21777 }
21778 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21779 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21780 }
21781 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21782 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21783 }
21784 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21785 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21786 }
21787 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21788 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21789 }
21790 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21791 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21792 }
21793 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21794 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21795 }
21796 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21797 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21798 }
21799 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21800 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21801 }
21802 static void *_p_wxImageTo_p_wxObject(void *x) {
21803 return (void *)((wxObject *) ((wxImage *) x));
21804 }
21805 static void *_p_wxFrameTo_p_wxObject(void *x) {
21806 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21807 }
21808 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21809 return (void *)((wxObject *) ((wxPyPrintout *) x));
21810 }
21811 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21812 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21813 }
21814 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21815 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21816 }
21817 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21818 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21819 }
21820 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21821 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21822 }
21823 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21824 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21825 }
21826 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21827 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21828 }
21829 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21830 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21831 }
21832 static void *_p_wxWindowTo_p_wxObject(void *x) {
21833 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21834 }
21835 static void *_p_wxMenuTo_p_wxObject(void *x) {
21836 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21837 }
21838 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21839 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21840 }
21841 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21842 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21843 }
21844 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21845 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21846 }
21847 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21848 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21849 }
21850 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21851 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21852 }
21853 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21854 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21855 }
21856 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21857 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21858 }
21859 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21860 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21861 }
21862 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21863 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21864 }
21865 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21866 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21867 }
21868 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21869 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21870 }
21871 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21872 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21873 }
21874 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21875 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21876 }
21877 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21878 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21879 }
21880 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21881 return (void *)((wxObject *) ((wxPrintPreview *) x));
21882 }
21883 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21884 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21885 }
21886 static void *_p_wxPanelTo_p_wxObject(void *x) {
21887 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21888 }
21889 static void *_p_wxDialogTo_p_wxObject(void *x) {
21890 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21891 }
21892 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21893 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21894 }
21895 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21896 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21897 }
21898 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21899 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21900 }
21901 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21902 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21903 }
21904 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21905 return (void *)((wxObject *) ((wxPrintDialog *) x));
21906 }
21907 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21908 return (void *)((wxObject *) ((wxFileSystem *) x));
21909 }
21910 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21911 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21912 }
21913 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21914 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21915 }
21916 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21917 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21918 }
21919 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21920 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21921 }
21922 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21923 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21924 }
21925 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21926 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21927 }
21928 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21929 return (void *)((wxObject *) ((wxGridTableBase *) x));
21930 }
21931 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21932 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21933 }
21934 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21935 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21936 }
21937 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21938 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21939 }
21940 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21941 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21942 }
21943 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21944 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21945 }
21946 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21947 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21948 }
21949 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21950 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21951 }
21952 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21953 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21954 }
21955 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21956 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21957 }
21958 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21959 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21960 }
21961 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21962 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21963 }
21964 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21965 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21966 }
21967 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21968 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21969 }
21970 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21971 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21972 }
21973 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21974 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21975 }
21976 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21977 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21978 }
21979 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21980 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21981 }
21982 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21983 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21984 }
21985 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21986 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21987 }
21988 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21989 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21990 }
21991 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21992 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21993 }
21994 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21995 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21996 }
21997 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21998 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21999 }
22000 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22001 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22002 }
22003 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22004 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22005 }
22006 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22007 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22008 }
22009 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22010 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22011 }
22012 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22013 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22014 }
22015 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22016 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22017 }
22018 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22019 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22020 }
22021 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22022 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22023 }
22024 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22025 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22026 }
22027 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22028 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22029 }
22030 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22031 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22032 }
22033 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22034 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22035 }
22036 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22037 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22038 }
22039 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22040 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22041 }
22042 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22043 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22044 }
22045 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22046 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22047 }
22048 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22049 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22050 }
22051 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22052 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22053 }
22054 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22055 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22056 }
22057 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22058 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22059 }
22060 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22061 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22062 }
22063 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22064 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22065 }
22066 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22067 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22068 }
22069 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22070 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22071 }
22072 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22073 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22074 }
22075 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22076 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22077 }
22078 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22079 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22080 }
22081 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22082 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22083 }
22084 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22085 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22086 }
22087 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22088 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22089 }
22090 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22091 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22092 }
22093 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22094 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22095 }
22096 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22097 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22098 }
22099 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22100 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22101 }
22102 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22103 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22104 }
22105 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22106 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22107 }
22108 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22109 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22110 }
22111 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22112 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22113 }
22114 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22115 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22116 }
22117 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22118 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22119 }
22120 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22121 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22122 }
22123 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22124 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22125 }
22126 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22127 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22128 }
22129 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22130 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22131 }
22132 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22133 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22134 }
22135 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22136 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22137 }
22138 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22139 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22140 }
22141 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22142 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22143 }
22144 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22145 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22146 }
22147 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22148 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22149 }
22150 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22151 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22152 }
22153 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22154 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22155 }
22156 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22157 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22158 }
22159 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22160 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22161 }
22162 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22163 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22164 }
22165 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22166 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22167 }
22168 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22169 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22170 }
22171 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22172 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22173 }
22174 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22175 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22176 }
22177 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22178 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22179 }
22180 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22181 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22182 }
22183 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22184 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22185 }
22186 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22187 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22188 }
22189 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22190 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22191 }
22192 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22193 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22194 }
22195 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22196 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22197 }
22198 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22199 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22200 }
22201 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22202 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22203 }
22204 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22205 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22206 }
22207 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22208 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22209 }
22210 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22211 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22212 }
22213 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22214 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22215 }
22216 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22217 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22218 }
22219 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22220 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};
22221 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22222 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22223 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22224 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22225 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22226 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22227 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22228 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22229 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22230 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22231 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22232 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22233 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22234 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22235 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22236 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22237 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22238 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22239 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22240 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22241 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22242 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22243 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22244 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22245 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22246 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22247 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22248 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22249 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22250 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22255 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22256 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22257 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22258 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22259 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22260 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22263 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22265 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22266 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22267 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22272 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22273 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22274 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22275 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22276 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22277 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22278 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22279 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22280 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22281 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22282 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22283 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22284 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22285 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22286 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22287 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22288 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22289 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22290 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22291 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22292 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22293 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22294 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22295 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22296 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22297 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22298 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22299 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22300 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22301 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22302 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22303 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22304 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22305 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22306 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22307 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22308 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22309 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22310 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22311 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22312 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22313 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22314 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22315 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22316 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22317 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22318 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22319 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22320 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22321 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22322 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22323 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22324 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22325 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22326 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22327 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22328 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22329 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22330 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22331 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22332 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22333 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22334 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22335 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22336 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22337 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22338 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22339 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22340 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22341 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22342 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22343 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22344 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22345 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22346 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22347 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22348 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22349 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22350 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22351 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22352 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22353 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22354 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22355 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22356 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22357 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22358 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22359 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22360 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22361 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22362 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22363 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22364 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22365 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22366 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22367 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22368 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22369 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22370 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22371 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22372 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22373 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22374 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22375 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22376 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22378 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22380 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22381 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22382 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22398 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22399 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22400 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22401 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22402 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22403 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22404 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22405 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22406 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22407 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22408 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22409 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22410 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22411
22412 static swig_type_info *swig_type_initial[] = {
22413 &_swigt__p_char,
22414 &_swigt__p_form_ops_t,
22415 &_swigt__p_int,
22416 &_swigt__p_long,
22417 &_swigt__p_unsigned_char,
22418 &_swigt__p_unsigned_int,
22419 &_swigt__p_unsigned_long,
22420 &_swigt__p_wxANIHandler,
22421 &_swigt__p_wxAcceleratorTable,
22422 &_swigt__p_wxActivateEvent,
22423 &_swigt__p_wxArrayString,
22424 &_swigt__p_wxBMPHandler,
22425 &_swigt__p_wxBoxSizer,
22426 &_swigt__p_wxCURHandler,
22427 &_swigt__p_wxCalculateLayoutEvent,
22428 &_swigt__p_wxChildFocusEvent,
22429 &_swigt__p_wxClipboardTextEvent,
22430 &_swigt__p_wxCloseEvent,
22431 &_swigt__p_wxColour,
22432 &_swigt__p_wxColourData,
22433 &_swigt__p_wxColourDialog,
22434 &_swigt__p_wxCommandEvent,
22435 &_swigt__p_wxContextMenuEvent,
22436 &_swigt__p_wxControl,
22437 &_swigt__p_wxControlWithItems,
22438 &_swigt__p_wxDC,
22439 &_swigt__p_wxDateEvent,
22440 &_swigt__p_wxDialog,
22441 &_swigt__p_wxDirDialog,
22442 &_swigt__p_wxDisplayChangedEvent,
22443 &_swigt__p_wxDropFilesEvent,
22444 &_swigt__p_wxDuplexMode,
22445 &_swigt__p_wxEraseEvent,
22446 &_swigt__p_wxEvent,
22447 &_swigt__p_wxEvtHandler,
22448 &_swigt__p_wxFSFile,
22449 &_swigt__p_wxFileDialog,
22450 &_swigt__p_wxFileSystem,
22451 &_swigt__p_wxFindDialogEvent,
22452 &_swigt__p_wxFindReplaceData,
22453 &_swigt__p_wxFindReplaceDialog,
22454 &_swigt__p_wxFlexGridSizer,
22455 &_swigt__p_wxFocusEvent,
22456 &_swigt__p_wxFont,
22457 &_swigt__p_wxFontData,
22458 &_swigt__p_wxFontDialog,
22459 &_swigt__p_wxFrame,
22460 &_swigt__p_wxGBSizerItem,
22461 &_swigt__p_wxGIFHandler,
22462 &_swigt__p_wxGrid,
22463 &_swigt__p_wxGridBagSizer,
22464 &_swigt__p_wxGridCellAttr,
22465 &_swigt__p_wxGridCellAttrProvider,
22466 &_swigt__p_wxGridCellAutoWrapStringEditor,
22467 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22468 &_swigt__p_wxGridCellBoolEditor,
22469 &_swigt__p_wxGridCellBoolRenderer,
22470 &_swigt__p_wxGridCellChoiceEditor,
22471 &_swigt__p_wxGridCellCoords,
22472 &_swigt__p_wxGridCellDateTimeRenderer,
22473 &_swigt__p_wxGridCellEditor,
22474 &_swigt__p_wxGridCellEnumEditor,
22475 &_swigt__p_wxGridCellEnumRenderer,
22476 &_swigt__p_wxGridCellFloatEditor,
22477 &_swigt__p_wxGridCellFloatRenderer,
22478 &_swigt__p_wxGridCellNumberEditor,
22479 &_swigt__p_wxGridCellNumberRenderer,
22480 &_swigt__p_wxGridCellRenderer,
22481 &_swigt__p_wxGridCellStringRenderer,
22482 &_swigt__p_wxGridCellTextEditor,
22483 &_swigt__p_wxGridCellWorker,
22484 &_swigt__p_wxGridEditorCreatedEvent,
22485 &_swigt__p_wxGridEvent,
22486 &_swigt__p_wxGridRangeSelectEvent,
22487 &_swigt__p_wxGridSizeEvent,
22488 &_swigt__p_wxGridSizer,
22489 &_swigt__p_wxGridStringTable,
22490 &_swigt__p_wxGridTableBase,
22491 &_swigt__p_wxGridTableMessage,
22492 &_swigt__p_wxICOHandler,
22493 &_swigt__p_wxIconizeEvent,
22494 &_swigt__p_wxIdleEvent,
22495 &_swigt__p_wxImage,
22496 &_swigt__p_wxImageHandler,
22497 &_swigt__p_wxIndividualLayoutConstraint,
22498 &_swigt__p_wxInitDialogEvent,
22499 &_swigt__p_wxJPEGHandler,
22500 &_swigt__p_wxKeyEvent,
22501 &_swigt__p_wxLayoutAlgorithm,
22502 &_swigt__p_wxLayoutConstraints,
22503 &_swigt__p_wxMDIChildFrame,
22504 &_swigt__p_wxMDIClientWindow,
22505 &_swigt__p_wxMDIParentFrame,
22506 &_swigt__p_wxMaximizeEvent,
22507 &_swigt__p_wxMenu,
22508 &_swigt__p_wxMenuBar,
22509 &_swigt__p_wxMenuEvent,
22510 &_swigt__p_wxMenuItem,
22511 &_swigt__p_wxMessageDialog,
22512 &_swigt__p_wxMiniFrame,
22513 &_swigt__p_wxMouseCaptureChangedEvent,
22514 &_swigt__p_wxMouseCaptureLostEvent,
22515 &_swigt__p_wxMouseEvent,
22516 &_swigt__p_wxMoveEvent,
22517 &_swigt__p_wxMultiChoiceDialog,
22518 &_swigt__p_wxNavigationKeyEvent,
22519 &_swigt__p_wxNcPaintEvent,
22520 &_swigt__p_wxNotifyEvent,
22521 &_swigt__p_wxNumberEntryDialog,
22522 &_swigt__p_wxObject,
22523 &_swigt__p_wxPCXHandler,
22524 &_swigt__p_wxPNGHandler,
22525 &_swigt__p_wxPNMHandler,
22526 &_swigt__p_wxPageSetupDialog,
22527 &_swigt__p_wxPageSetupDialogData,
22528 &_swigt__p_wxPaintEvent,
22529 &_swigt__p_wxPaletteChangedEvent,
22530 &_swigt__p_wxPanel,
22531 &_swigt__p_wxPaperSize,
22532 &_swigt__p_wxPasswordEntryDialog,
22533 &_swigt__p_wxPen,
22534 &_swigt__p_wxPoint,
22535 &_swigt__p_wxPopupWindow,
22536 &_swigt__p_wxPreviewCanvas,
22537 &_swigt__p_wxPreviewControlBar,
22538 &_swigt__p_wxPreviewFrame,
22539 &_swigt__p_wxPrintData,
22540 &_swigt__p_wxPrintDialog,
22541 &_swigt__p_wxPrintDialogData,
22542 &_swigt__p_wxPrintPreview,
22543 &_swigt__p_wxPrinter,
22544 &_swigt__p_wxProgressDialog,
22545 &_swigt__p_wxPyApp,
22546 &_swigt__p_wxPyCommandEvent,
22547 &_swigt__p_wxPyEvent,
22548 &_swigt__p_wxPyGridCellAttrProvider,
22549 &_swigt__p_wxPyGridCellEditor,
22550 &_swigt__p_wxPyGridCellRenderer,
22551 &_swigt__p_wxPyGridTableBase,
22552 &_swigt__p_wxPyHtmlListBox,
22553 &_swigt__p_wxPyImageHandler,
22554 &_swigt__p_wxPyPanel,
22555 &_swigt__p_wxPyPopupTransientWindow,
22556 &_swigt__p_wxPyPreviewControlBar,
22557 &_swigt__p_wxPyPreviewFrame,
22558 &_swigt__p_wxPyPrintPreview,
22559 &_swigt__p_wxPyPrintout,
22560 &_swigt__p_wxPyScrolledWindow,
22561 &_swigt__p_wxPySizer,
22562 &_swigt__p_wxPyTaskBarIcon,
22563 &_swigt__p_wxPyVListBox,
22564 &_swigt__p_wxPyVScrolledWindow,
22565 &_swigt__p_wxPyValidator,
22566 &_swigt__p_wxPyWindow,
22567 &_swigt__p_wxQueryLayoutInfoEvent,
22568 &_swigt__p_wxQueryNewPaletteEvent,
22569 &_swigt__p_wxRect,
22570 &_swigt__p_wxSashEvent,
22571 &_swigt__p_wxSashLayoutWindow,
22572 &_swigt__p_wxSashWindow,
22573 &_swigt__p_wxScrollEvent,
22574 &_swigt__p_wxScrollWinEvent,
22575 &_swigt__p_wxScrolledWindow,
22576 &_swigt__p_wxSetCursorEvent,
22577 &_swigt__p_wxShowEvent,
22578 &_swigt__p_wxSingleChoiceDialog,
22579 &_swigt__p_wxSize,
22580 &_swigt__p_wxSizeEvent,
22581 &_swigt__p_wxSizer,
22582 &_swigt__p_wxSizerItem,
22583 &_swigt__p_wxSplashScreen,
22584 &_swigt__p_wxSplashScreenWindow,
22585 &_swigt__p_wxSplitterEvent,
22586 &_swigt__p_wxSplitterWindow,
22587 &_swigt__p_wxStaticBoxSizer,
22588 &_swigt__p_wxStatusBar,
22589 &_swigt__p_wxStdDialogButtonSizer,
22590 &_swigt__p_wxString,
22591 &_swigt__p_wxSysColourChangedEvent,
22592 &_swigt__p_wxTGAHandler,
22593 &_swigt__p_wxTIFFHandler,
22594 &_swigt__p_wxTaskBarIconEvent,
22595 &_swigt__p_wxTextEntryDialog,
22596 &_swigt__p_wxTipWindow,
22597 &_swigt__p_wxTopLevelWindow,
22598 &_swigt__p_wxUpdateUIEvent,
22599 &_swigt__p_wxValidator,
22600 &_swigt__p_wxVisualAttributes,
22601 &_swigt__p_wxWindow,
22602 &_swigt__p_wxWindowCreateEvent,
22603 &_swigt__p_wxWindowDestroyEvent,
22604 &_swigt__p_wxXPMHandler,
22605 };
22606
22607 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22608 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22609 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22610 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22611 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22612 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22613 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22614 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22615 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22616 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22617 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22618 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22619 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22620 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22621 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22622 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22623 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22624 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22625 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22626 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22627 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22628 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}};
22629 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22630 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}};
22631 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22632 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22643 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22644 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22645 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22646 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22647 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22653 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22654 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22655 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22656 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22658 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22659 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22662 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}};
22663 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22667 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22668 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22672 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22673 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22674 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22675 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22676 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22677 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22678 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22679 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22680 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22681 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22682 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22683 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22684 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22685 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22686 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22687 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22688 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22689 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22690 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22691 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22692 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22693 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22694 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22695 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22696 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22697 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22698 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22699 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22700 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22701 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22702 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22703 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22704 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22705 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22706 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22707 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22708 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}};
22709 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22710 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22711 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22712 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}};
22713 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22714 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22715 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22716 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22717 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}};
22718 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22719 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22720 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}};
22721 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22722 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22723 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22724 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22725 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22726 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22727 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}};
22728 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}};
22729 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}};
22730 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}};
22731 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22732 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22733 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22734 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22735 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22736 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}};
22737 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22738 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22739 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}};
22740 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22741 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22742 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22743 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22744 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22745 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22746 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22747 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22748 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22749 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22752 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22753 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22754 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22755 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22756 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22757 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22758 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22763 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22764 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22766 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22767 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22770 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22771 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22772 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22773 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22778 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22779 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22785 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}};
22786 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22794 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}};
22795 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22798 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}};
22799
22800 static swig_cast_info *swig_cast_initial[] = {
22801 _swigc__p_char,
22802 _swigc__p_form_ops_t,
22803 _swigc__p_int,
22804 _swigc__p_long,
22805 _swigc__p_unsigned_char,
22806 _swigc__p_unsigned_int,
22807 _swigc__p_unsigned_long,
22808 _swigc__p_wxANIHandler,
22809 _swigc__p_wxAcceleratorTable,
22810 _swigc__p_wxActivateEvent,
22811 _swigc__p_wxArrayString,
22812 _swigc__p_wxBMPHandler,
22813 _swigc__p_wxBoxSizer,
22814 _swigc__p_wxCURHandler,
22815 _swigc__p_wxCalculateLayoutEvent,
22816 _swigc__p_wxChildFocusEvent,
22817 _swigc__p_wxClipboardTextEvent,
22818 _swigc__p_wxCloseEvent,
22819 _swigc__p_wxColour,
22820 _swigc__p_wxColourData,
22821 _swigc__p_wxColourDialog,
22822 _swigc__p_wxCommandEvent,
22823 _swigc__p_wxContextMenuEvent,
22824 _swigc__p_wxControl,
22825 _swigc__p_wxControlWithItems,
22826 _swigc__p_wxDC,
22827 _swigc__p_wxDateEvent,
22828 _swigc__p_wxDialog,
22829 _swigc__p_wxDirDialog,
22830 _swigc__p_wxDisplayChangedEvent,
22831 _swigc__p_wxDropFilesEvent,
22832 _swigc__p_wxDuplexMode,
22833 _swigc__p_wxEraseEvent,
22834 _swigc__p_wxEvent,
22835 _swigc__p_wxEvtHandler,
22836 _swigc__p_wxFSFile,
22837 _swigc__p_wxFileDialog,
22838 _swigc__p_wxFileSystem,
22839 _swigc__p_wxFindDialogEvent,
22840 _swigc__p_wxFindReplaceData,
22841 _swigc__p_wxFindReplaceDialog,
22842 _swigc__p_wxFlexGridSizer,
22843 _swigc__p_wxFocusEvent,
22844 _swigc__p_wxFont,
22845 _swigc__p_wxFontData,
22846 _swigc__p_wxFontDialog,
22847 _swigc__p_wxFrame,
22848 _swigc__p_wxGBSizerItem,
22849 _swigc__p_wxGIFHandler,
22850 _swigc__p_wxGrid,
22851 _swigc__p_wxGridBagSizer,
22852 _swigc__p_wxGridCellAttr,
22853 _swigc__p_wxGridCellAttrProvider,
22854 _swigc__p_wxGridCellAutoWrapStringEditor,
22855 _swigc__p_wxGridCellAutoWrapStringRenderer,
22856 _swigc__p_wxGridCellBoolEditor,
22857 _swigc__p_wxGridCellBoolRenderer,
22858 _swigc__p_wxGridCellChoiceEditor,
22859 _swigc__p_wxGridCellCoords,
22860 _swigc__p_wxGridCellDateTimeRenderer,
22861 _swigc__p_wxGridCellEditor,
22862 _swigc__p_wxGridCellEnumEditor,
22863 _swigc__p_wxGridCellEnumRenderer,
22864 _swigc__p_wxGridCellFloatEditor,
22865 _swigc__p_wxGridCellFloatRenderer,
22866 _swigc__p_wxGridCellNumberEditor,
22867 _swigc__p_wxGridCellNumberRenderer,
22868 _swigc__p_wxGridCellRenderer,
22869 _swigc__p_wxGridCellStringRenderer,
22870 _swigc__p_wxGridCellTextEditor,
22871 _swigc__p_wxGridCellWorker,
22872 _swigc__p_wxGridEditorCreatedEvent,
22873 _swigc__p_wxGridEvent,
22874 _swigc__p_wxGridRangeSelectEvent,
22875 _swigc__p_wxGridSizeEvent,
22876 _swigc__p_wxGridSizer,
22877 _swigc__p_wxGridStringTable,
22878 _swigc__p_wxGridTableBase,
22879 _swigc__p_wxGridTableMessage,
22880 _swigc__p_wxICOHandler,
22881 _swigc__p_wxIconizeEvent,
22882 _swigc__p_wxIdleEvent,
22883 _swigc__p_wxImage,
22884 _swigc__p_wxImageHandler,
22885 _swigc__p_wxIndividualLayoutConstraint,
22886 _swigc__p_wxInitDialogEvent,
22887 _swigc__p_wxJPEGHandler,
22888 _swigc__p_wxKeyEvent,
22889 _swigc__p_wxLayoutAlgorithm,
22890 _swigc__p_wxLayoutConstraints,
22891 _swigc__p_wxMDIChildFrame,
22892 _swigc__p_wxMDIClientWindow,
22893 _swigc__p_wxMDIParentFrame,
22894 _swigc__p_wxMaximizeEvent,
22895 _swigc__p_wxMenu,
22896 _swigc__p_wxMenuBar,
22897 _swigc__p_wxMenuEvent,
22898 _swigc__p_wxMenuItem,
22899 _swigc__p_wxMessageDialog,
22900 _swigc__p_wxMiniFrame,
22901 _swigc__p_wxMouseCaptureChangedEvent,
22902 _swigc__p_wxMouseCaptureLostEvent,
22903 _swigc__p_wxMouseEvent,
22904 _swigc__p_wxMoveEvent,
22905 _swigc__p_wxMultiChoiceDialog,
22906 _swigc__p_wxNavigationKeyEvent,
22907 _swigc__p_wxNcPaintEvent,
22908 _swigc__p_wxNotifyEvent,
22909 _swigc__p_wxNumberEntryDialog,
22910 _swigc__p_wxObject,
22911 _swigc__p_wxPCXHandler,
22912 _swigc__p_wxPNGHandler,
22913 _swigc__p_wxPNMHandler,
22914 _swigc__p_wxPageSetupDialog,
22915 _swigc__p_wxPageSetupDialogData,
22916 _swigc__p_wxPaintEvent,
22917 _swigc__p_wxPaletteChangedEvent,
22918 _swigc__p_wxPanel,
22919 _swigc__p_wxPaperSize,
22920 _swigc__p_wxPasswordEntryDialog,
22921 _swigc__p_wxPen,
22922 _swigc__p_wxPoint,
22923 _swigc__p_wxPopupWindow,
22924 _swigc__p_wxPreviewCanvas,
22925 _swigc__p_wxPreviewControlBar,
22926 _swigc__p_wxPreviewFrame,
22927 _swigc__p_wxPrintData,
22928 _swigc__p_wxPrintDialog,
22929 _swigc__p_wxPrintDialogData,
22930 _swigc__p_wxPrintPreview,
22931 _swigc__p_wxPrinter,
22932 _swigc__p_wxProgressDialog,
22933 _swigc__p_wxPyApp,
22934 _swigc__p_wxPyCommandEvent,
22935 _swigc__p_wxPyEvent,
22936 _swigc__p_wxPyGridCellAttrProvider,
22937 _swigc__p_wxPyGridCellEditor,
22938 _swigc__p_wxPyGridCellRenderer,
22939 _swigc__p_wxPyGridTableBase,
22940 _swigc__p_wxPyHtmlListBox,
22941 _swigc__p_wxPyImageHandler,
22942 _swigc__p_wxPyPanel,
22943 _swigc__p_wxPyPopupTransientWindow,
22944 _swigc__p_wxPyPreviewControlBar,
22945 _swigc__p_wxPyPreviewFrame,
22946 _swigc__p_wxPyPrintPreview,
22947 _swigc__p_wxPyPrintout,
22948 _swigc__p_wxPyScrolledWindow,
22949 _swigc__p_wxPySizer,
22950 _swigc__p_wxPyTaskBarIcon,
22951 _swigc__p_wxPyVListBox,
22952 _swigc__p_wxPyVScrolledWindow,
22953 _swigc__p_wxPyValidator,
22954 _swigc__p_wxPyWindow,
22955 _swigc__p_wxQueryLayoutInfoEvent,
22956 _swigc__p_wxQueryNewPaletteEvent,
22957 _swigc__p_wxRect,
22958 _swigc__p_wxSashEvent,
22959 _swigc__p_wxSashLayoutWindow,
22960 _swigc__p_wxSashWindow,
22961 _swigc__p_wxScrollEvent,
22962 _swigc__p_wxScrollWinEvent,
22963 _swigc__p_wxScrolledWindow,
22964 _swigc__p_wxSetCursorEvent,
22965 _swigc__p_wxShowEvent,
22966 _swigc__p_wxSingleChoiceDialog,
22967 _swigc__p_wxSize,
22968 _swigc__p_wxSizeEvent,
22969 _swigc__p_wxSizer,
22970 _swigc__p_wxSizerItem,
22971 _swigc__p_wxSplashScreen,
22972 _swigc__p_wxSplashScreenWindow,
22973 _swigc__p_wxSplitterEvent,
22974 _swigc__p_wxSplitterWindow,
22975 _swigc__p_wxStaticBoxSizer,
22976 _swigc__p_wxStatusBar,
22977 _swigc__p_wxStdDialogButtonSizer,
22978 _swigc__p_wxString,
22979 _swigc__p_wxSysColourChangedEvent,
22980 _swigc__p_wxTGAHandler,
22981 _swigc__p_wxTIFFHandler,
22982 _swigc__p_wxTaskBarIconEvent,
22983 _swigc__p_wxTextEntryDialog,
22984 _swigc__p_wxTipWindow,
22985 _swigc__p_wxTopLevelWindow,
22986 _swigc__p_wxUpdateUIEvent,
22987 _swigc__p_wxValidator,
22988 _swigc__p_wxVisualAttributes,
22989 _swigc__p_wxWindow,
22990 _swigc__p_wxWindowCreateEvent,
22991 _swigc__p_wxWindowDestroyEvent,
22992 _swigc__p_wxXPMHandler,
22993 };
22994
22995
22996 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22997
22998 static swig_const_info swig_const_table[] = {
22999 {0, 0, 0, 0.0, 0, 0}};
23000
23001 #ifdef __cplusplus
23002 }
23003 #endif
23004 /* -----------------------------------------------------------------------------
23005 * Type initialization:
23006 * This problem is tough by the requirement that no dynamic
23007 * memory is used. Also, since swig_type_info structures store pointers to
23008 * swig_cast_info structures and swig_cast_info structures store pointers back
23009 * to swig_type_info structures, we need some lookup code at initialization.
23010 * The idea is that swig generates all the structures that are needed.
23011 * The runtime then collects these partially filled structures.
23012 * The SWIG_InitializeModule function takes these initial arrays out of
23013 * swig_module, and does all the lookup, filling in the swig_module.types
23014 * array with the correct data and linking the correct swig_cast_info
23015 * structures together.
23016 *
23017 * The generated swig_type_info structures are assigned staticly to an initial
23018 * array. We just loop though that array, and handle each type individually.
23019 * First we lookup if this type has been already loaded, and if so, use the
23020 * loaded structure instead of the generated one. Then we have to fill in the
23021 * cast linked list. The cast data is initially stored in something like a
23022 * two-dimensional array. Each row corresponds to a type (there are the same
23023 * number of rows as there are in the swig_type_initial array). Each entry in
23024 * a column is one of the swig_cast_info structures for that type.
23025 * The cast_initial array is actually an array of arrays, because each row has
23026 * a variable number of columns. So to actually build the cast linked list,
23027 * we find the array of casts associated with the type, and loop through it
23028 * adding the casts to the list. The one last trick we need to do is making
23029 * sure the type pointer in the swig_cast_info struct is correct.
23030 *
23031 * First off, we lookup the cast->type name to see if it is already loaded.
23032 * There are three cases to handle:
23033 * 1) If the cast->type has already been loaded AND the type we are adding
23034 * casting info to has not been loaded (it is in this module), THEN we
23035 * replace the cast->type pointer with the type pointer that has already
23036 * been loaded.
23037 * 2) If BOTH types (the one we are adding casting info to, and the
23038 * cast->type) are loaded, THEN the cast info has already been loaded by
23039 * the previous module so we just ignore it.
23040 * 3) Finally, if cast->type has not already been loaded, then we add that
23041 * swig_cast_info to the linked list (because the cast->type) pointer will
23042 * be correct.
23043 * ----------------------------------------------------------------------------- */
23044
23045 #ifdef __cplusplus
23046 extern "C" {
23047 #if 0
23048 } /* c-mode */
23049 #endif
23050 #endif
23051
23052 #if 0
23053 #define SWIGRUNTIME_DEBUG
23054 #endif
23055
23056 SWIGRUNTIME void
23057 SWIG_InitializeModule(void *clientdata) {
23058 size_t i;
23059 swig_module_info *module_head;
23060 static int init_run = 0;
23061
23062 clientdata = clientdata;
23063
23064 if (init_run) return;
23065 init_run = 1;
23066
23067 /* Initialize the swig_module */
23068 swig_module.type_initial = swig_type_initial;
23069 swig_module.cast_initial = swig_cast_initial;
23070
23071 /* Try and load any already created modules */
23072 module_head = SWIG_GetModule(clientdata);
23073 if (module_head) {
23074 swig_module.next = module_head->next;
23075 module_head->next = &swig_module;
23076 } else {
23077 /* This is the first module loaded */
23078 swig_module.next = &swig_module;
23079 SWIG_SetModule(clientdata, &swig_module);
23080 }
23081
23082 /* Now work on filling in swig_module.types */
23083 #ifdef SWIGRUNTIME_DEBUG
23084 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23085 #endif
23086 for (i = 0; i < swig_module.size; ++i) {
23087 swig_type_info *type = 0;
23088 swig_type_info *ret;
23089 swig_cast_info *cast;
23090
23091 #ifdef SWIGRUNTIME_DEBUG
23092 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23093 #endif
23094
23095 /* if there is another module already loaded */
23096 if (swig_module.next != &swig_module) {
23097 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23098 }
23099 if (type) {
23100 /* Overwrite clientdata field */
23101 #ifdef SWIGRUNTIME_DEBUG
23102 printf("SWIG_InitializeModule: found type %s\n", type->name);
23103 #endif
23104 if (swig_module.type_initial[i]->clientdata) {
23105 type->clientdata = swig_module.type_initial[i]->clientdata;
23106 #ifdef SWIGRUNTIME_DEBUG
23107 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23108 #endif
23109 }
23110 } else {
23111 type = swig_module.type_initial[i];
23112 }
23113
23114 /* Insert casting types */
23115 cast = swig_module.cast_initial[i];
23116 while (cast->type) {
23117 /* Don't need to add information already in the list */
23118 ret = 0;
23119 #ifdef SWIGRUNTIME_DEBUG
23120 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23121 #endif
23122 if (swig_module.next != &swig_module) {
23123 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23124 #ifdef SWIGRUNTIME_DEBUG
23125 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23126 #endif
23127 }
23128 if (ret) {
23129 if (type == swig_module.type_initial[i]) {
23130 #ifdef SWIGRUNTIME_DEBUG
23131 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23132 #endif
23133 cast->type = ret;
23134 ret = 0;
23135 } else {
23136 /* Check for casting already in the list */
23137 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23138 #ifdef SWIGRUNTIME_DEBUG
23139 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23140 #endif
23141 if (!ocast) ret = 0;
23142 }
23143 }
23144
23145 if (!ret) {
23146 #ifdef SWIGRUNTIME_DEBUG
23147 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23148 #endif
23149 if (type->cast) {
23150 type->cast->prev = cast;
23151 cast->next = type->cast;
23152 }
23153 type->cast = cast;
23154 }
23155 cast++;
23156 }
23157 /* Set entry in modules->types array equal to the type */
23158 swig_module.types[i] = type;
23159 }
23160 swig_module.types[i] = 0;
23161
23162 #ifdef SWIGRUNTIME_DEBUG
23163 printf("**** SWIG_InitializeModule: Cast List ******\n");
23164 for (i = 0; i < swig_module.size; ++i) {
23165 int j = 0;
23166 swig_cast_info *cast = swig_module.cast_initial[i];
23167 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23168 while (cast->type) {
23169 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23170 cast++;
23171 ++j;
23172 }
23173 printf("---- Total casts: %d\n",j);
23174 }
23175 printf("**** SWIG_InitializeModule: Cast List ******\n");
23176 #endif
23177 }
23178
23179 /* This function will propagate the clientdata field of type to
23180 * any new swig_type_info structures that have been added into the list
23181 * of equivalent types. It is like calling
23182 * SWIG_TypeClientData(type, clientdata) a second time.
23183 */
23184 SWIGRUNTIME void
23185 SWIG_PropagateClientData(void) {
23186 size_t i;
23187 swig_cast_info *equiv;
23188 static int init_run = 0;
23189
23190 if (init_run) return;
23191 init_run = 1;
23192
23193 for (i = 0; i < swig_module.size; i++) {
23194 if (swig_module.types[i]->clientdata) {
23195 equiv = swig_module.types[i]->cast;
23196 while (equiv) {
23197 if (!equiv->converter) {
23198 if (equiv->type && !equiv->type->clientdata)
23199 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23200 }
23201 equiv = equiv->next;
23202 }
23203 }
23204 }
23205 }
23206
23207 #ifdef __cplusplus
23208 #if 0
23209 {
23210 /* c-mode */
23211 #endif
23212 }
23213 #endif
23214
23215
23216
23217 #ifdef __cplusplus
23218 extern "C" {
23219 #endif
23220
23221 /* Python-specific SWIG API */
23222 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23223 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23224 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23225
23226 /* -----------------------------------------------------------------------------
23227 * global variable support code.
23228 * ----------------------------------------------------------------------------- */
23229
23230 typedef struct swig_globalvar {
23231 char *name; /* Name of global variable */
23232 PyObject *(*get_attr)(void); /* Return the current value */
23233 int (*set_attr)(PyObject *); /* Set the value */
23234 struct swig_globalvar *next;
23235 } swig_globalvar;
23236
23237 typedef struct swig_varlinkobject {
23238 PyObject_HEAD
23239 swig_globalvar *vars;
23240 } swig_varlinkobject;
23241
23242 SWIGINTERN PyObject *
23243 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23244 return PyString_FromString("<Swig global variables>");
23245 }
23246
23247 SWIGINTERN PyObject *
23248 swig_varlink_str(swig_varlinkobject *v) {
23249 PyObject *str = PyString_FromString("(");
23250 swig_globalvar *var;
23251 for (var = v->vars; var; var=var->next) {
23252 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23253 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23254 }
23255 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23256 return str;
23257 }
23258
23259 SWIGINTERN int
23260 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23261 PyObject *str = swig_varlink_str(v);
23262 fprintf(fp,"Swig global variables ");
23263 fprintf(fp,"%s\n", PyString_AsString(str));
23264 Py_DECREF(str);
23265 return 0;
23266 }
23267
23268 SWIGINTERN void
23269 swig_varlink_dealloc(swig_varlinkobject *v) {
23270 swig_globalvar *var = v->vars;
23271 while (var) {
23272 swig_globalvar *n = var->next;
23273 free(var->name);
23274 free(var);
23275 var = n;
23276 }
23277 }
23278
23279 SWIGINTERN PyObject *
23280 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23281 PyObject *res = NULL;
23282 swig_globalvar *var = v->vars;
23283 while (var) {
23284 if (strcmp(var->name,n) == 0) {
23285 res = (*var->get_attr)();
23286 break;
23287 }
23288 var = var->next;
23289 }
23290 if (res == NULL && !PyErr_Occurred()) {
23291 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23292 }
23293 return res;
23294 }
23295
23296 SWIGINTERN int
23297 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23298 int res = 1;
23299 swig_globalvar *var = v->vars;
23300 while (var) {
23301 if (strcmp(var->name,n) == 0) {
23302 res = (*var->set_attr)(p);
23303 break;
23304 }
23305 var = var->next;
23306 }
23307 if (res == 1 && !PyErr_Occurred()) {
23308 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23309 }
23310 return res;
23311 }
23312
23313 SWIGINTERN PyTypeObject*
23314 swig_varlink_type(void) {
23315 static char varlink__doc__[] = "Swig var link object";
23316 static PyTypeObject varlink_type;
23317 static int type_init = 0;
23318 if (!type_init) {
23319 const PyTypeObject tmp
23320 = {
23321 PyObject_HEAD_INIT(NULL)
23322 0, /* Number of items in variable part (ob_size) */
23323 (char *)"swigvarlink", /* Type name (tp_name) */
23324 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23325 0, /* Itemsize (tp_itemsize) */
23326 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23327 (printfunc) swig_varlink_print, /* Print (tp_print) */
23328 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23329 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23330 0, /* tp_compare */
23331 (reprfunc) swig_varlink_repr, /* tp_repr */
23332 0, /* tp_as_number */
23333 0, /* tp_as_sequence */
23334 0, /* tp_as_mapping */
23335 0, /* tp_hash */
23336 0, /* tp_call */
23337 (reprfunc)swig_varlink_str, /* tp_str */
23338 0, /* tp_getattro */
23339 0, /* tp_setattro */
23340 0, /* tp_as_buffer */
23341 0, /* tp_flags */
23342 varlink__doc__, /* tp_doc */
23343 0, /* tp_traverse */
23344 0, /* tp_clear */
23345 0, /* tp_richcompare */
23346 0, /* tp_weaklistoffset */
23347 #if PY_VERSION_HEX >= 0x02020000
23348 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23349 #endif
23350 #if PY_VERSION_HEX >= 0x02030000
23351 0, /* tp_del */
23352 #endif
23353 #ifdef COUNT_ALLOCS
23354 0,0,0,0 /* tp_alloc -> tp_next */
23355 #endif
23356 };
23357 varlink_type = tmp;
23358 varlink_type.ob_type = &PyType_Type;
23359 type_init = 1;
23360 }
23361 return &varlink_type;
23362 }
23363
23364 /* Create a variable linking object for use later */
23365 SWIGINTERN PyObject *
23366 SWIG_Python_newvarlink(void) {
23367 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23368 if (result) {
23369 result->vars = 0;
23370 }
23371 return ((PyObject*) result);
23372 }
23373
23374 SWIGINTERN void
23375 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23376 swig_varlinkobject *v = (swig_varlinkobject *) p;
23377 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23378 if (gv) {
23379 size_t size = strlen(name)+1;
23380 gv->name = (char *)malloc(size);
23381 if (gv->name) {
23382 strncpy(gv->name,name,size);
23383 gv->get_attr = get_attr;
23384 gv->set_attr = set_attr;
23385 gv->next = v->vars;
23386 }
23387 }
23388 v->vars = gv;
23389 }
23390
23391 SWIGINTERN PyObject *
23392 SWIG_globals() {
23393 static PyObject *_SWIG_globals = 0;
23394 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23395 return _SWIG_globals;
23396 }
23397
23398 /* -----------------------------------------------------------------------------
23399 * constants/methods manipulation
23400 * ----------------------------------------------------------------------------- */
23401
23402 /* Install Constants */
23403 SWIGINTERN void
23404 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23405 PyObject *obj = 0;
23406 size_t i;
23407 for (i = 0; constants[i].type; ++i) {
23408 switch(constants[i].type) {
23409 case SWIG_PY_POINTER:
23410 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23411 break;
23412 case SWIG_PY_BINARY:
23413 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23414 break;
23415 default:
23416 obj = 0;
23417 break;
23418 }
23419 if (obj) {
23420 PyDict_SetItemString(d, constants[i].name, obj);
23421 Py_DECREF(obj);
23422 }
23423 }
23424 }
23425
23426 /* -----------------------------------------------------------------------------*/
23427 /* Fix SwigMethods to carry the callback ptrs when needed */
23428 /* -----------------------------------------------------------------------------*/
23429
23430 SWIGINTERN void
23431 SWIG_Python_FixMethods(PyMethodDef *methods,
23432 swig_const_info *const_table,
23433 swig_type_info **types,
23434 swig_type_info **types_initial) {
23435 size_t i;
23436 for (i = 0; methods[i].ml_name; ++i) {
23437 const char *c = methods[i].ml_doc;
23438 if (c && (c = strstr(c, "swig_ptr: "))) {
23439 int j;
23440 swig_const_info *ci = 0;
23441 const char *name = c + 10;
23442 for (j = 0; const_table[j].type; ++j) {
23443 if (strncmp(const_table[j].name, name,
23444 strlen(const_table[j].name)) == 0) {
23445 ci = &(const_table[j]);
23446 break;
23447 }
23448 }
23449 if (ci) {
23450 size_t shift = (ci->ptype) - types;
23451 swig_type_info *ty = types_initial[shift];
23452 size_t ldoc = (c - methods[i].ml_doc);
23453 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23454 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23455 if (ndoc) {
23456 char *buff = ndoc;
23457 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23458 if (ptr) {
23459 strncpy(buff, methods[i].ml_doc, ldoc);
23460 buff += ldoc;
23461 strncpy(buff, "swig_ptr: ", 10);
23462 buff += 10;
23463 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23464 methods[i].ml_doc = ndoc;
23465 }
23466 }
23467 }
23468 }
23469 }
23470 }
23471
23472 #ifdef __cplusplus
23473 }
23474 #endif
23475
23476 /* -----------------------------------------------------------------------------*
23477 * Partial Init method
23478 * -----------------------------------------------------------------------------*/
23479
23480 #ifdef __cplusplus
23481 extern "C"
23482 #endif
23483 SWIGEXPORT void SWIG_init(void) {
23484 PyObject *m, *d;
23485
23486 /* Fix SwigMethods to carry the callback ptrs when needed */
23487 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23488
23489 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23490 d = PyModule_GetDict(m);
23491
23492 SWIG_InitializeModule(0);
23493 SWIG_InstallConstants(d,swig_const_table);
23494
23495
23496 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23497 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23498 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23499 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23500 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23501 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23502 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23503 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23504 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23505 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23506 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23507 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23508 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23509 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23510 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23511 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23512 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23513 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23514 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23515 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23516 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23517 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23518 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23519 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23520 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23521 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23522 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23523 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23524 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23525 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23526 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23527 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23528 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23529 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23530 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23531 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23532 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23533 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23534 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23535 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23536 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23537 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23538 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23539 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23540 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23541 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23542 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23543 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23544 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23545 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23546 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23547 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23548 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23549 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23550 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23551 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23552 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23553
23554
23555 }
23556
wxWidgets (Impactor)