]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update the text of a read-only combobox (and hence wxChoice) when selection is change...
[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_wxSimpleHtmlListBox swig_types[165]
2632 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[166]
2633 #define SWIGTYPE_p_wxSize swig_types[167]
2634 #define SWIGTYPE_p_wxSizeEvent swig_types[168]
2635 #define SWIGTYPE_p_wxSizer swig_types[169]
2636 #define SWIGTYPE_p_wxSizerItem swig_types[170]
2637 #define SWIGTYPE_p_wxSplashScreen swig_types[171]
2638 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[172]
2639 #define SWIGTYPE_p_wxSplitterEvent swig_types[173]
2640 #define SWIGTYPE_p_wxSplitterWindow swig_types[174]
2641 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[175]
2642 #define SWIGTYPE_p_wxStatusBar swig_types[176]
2643 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[177]
2644 #define SWIGTYPE_p_wxString swig_types[178]
2645 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[179]
2646 #define SWIGTYPE_p_wxTGAHandler swig_types[180]
2647 #define SWIGTYPE_p_wxTIFFHandler swig_types[181]
2648 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[182]
2649 #define SWIGTYPE_p_wxTextEntryDialog swig_types[183]
2650 #define SWIGTYPE_p_wxTipWindow swig_types[184]
2651 #define SWIGTYPE_p_wxTopLevelWindow swig_types[185]
2652 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[186]
2653 #define SWIGTYPE_p_wxValidator swig_types[187]
2654 #define SWIGTYPE_p_wxVisualAttributes swig_types[188]
2655 #define SWIGTYPE_p_wxWindow swig_types[189]
2656 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[190]
2657 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[191]
2658 #define SWIGTYPE_p_wxXPMHandler swig_types[192]
2659 static swig_type_info *swig_types[194];
2660 static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0};
2661 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2662 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2663
2664 /* -------- TYPES TABLE (END) -------- */
2665
2666 #if (PY_VERSION_HEX <= 0x02000000)
2667 # if !defined(SWIG_PYTHON_CLASSIC)
2668 # error "This python version requires to use swig with the '-classic' option"
2669 # endif
2670 #endif
2671 #if (PY_VERSION_HEX <= 0x02020000)
2672 # error "This python version requires to use swig with the '-nomodern' option"
2673 #endif
2674 #if (PY_VERSION_HEX <= 0x02020000)
2675 # error "This python version requires to use swig with the '-nomodernargs' option"
2676 #endif
2677 #ifndef METH_O
2678 # error "This python version requires to use swig with the '-nofastunpack' option"
2679 #endif
2680
2681 /*-----------------------------------------------
2682 @(target):= _grid.so
2683 ------------------------------------------------*/
2684 #define SWIG_init init_grid
2685
2686 #define SWIG_name "_grid"
2687
2688 #define SWIGVERSION 0x010329
2689
2690
2691 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2692 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2693
2694
2695 #include <stdexcept>
2696
2697
2698 namespace swig {
2699 class PyObject_ptr {
2700 protected:
2701 PyObject *_obj;
2702
2703 public:
2704 PyObject_ptr() :_obj(0)
2705 {
2706 }
2707
2708 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2709 {
2710 Py_XINCREF(_obj);
2711 }
2712
2713 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2714 {
2715 if (initial_ref) Py_XINCREF(_obj);
2716 }
2717
2718 PyObject_ptr & operator=(const PyObject_ptr& item)
2719 {
2720 Py_XINCREF(item._obj);
2721 Py_XDECREF(_obj);
2722 _obj = item._obj;
2723 return *this;
2724 }
2725
2726 ~PyObject_ptr()
2727 {
2728 Py_XDECREF(_obj);
2729 }
2730
2731 operator PyObject *() const
2732 {
2733 return _obj;
2734 }
2735
2736 PyObject *operator->() const
2737 {
2738 return _obj;
2739 }
2740 };
2741 }
2742
2743
2744 namespace swig {
2745 struct PyObject_var : PyObject_ptr {
2746 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2747
2748 PyObject_var & operator = (PyObject* obj)
2749 {
2750 Py_XDECREF(_obj);
2751 _obj = obj;
2752 return *this;
2753 }
2754 };
2755 }
2756
2757
2758 #include "wx/wxPython/wxPython.h"
2759 #include "wx/wxPython/pyclasses.h"
2760 #include "wx/wxPython/printfw.h"
2761
2762 #include <wx/grid.h>
2763 #include <wx/generic/gridctrl.h>
2764
2765
2766 static const wxString wxPyEmptyString(wxEmptyString);
2767 static const wxString wxPyGridNameStr(wxGridNameStr);
2768 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2769
2770
2771 #define wxPyMake_TEMPLATE(TYPE) \
2772 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2773 PyObject* target = NULL; \
2774 if (source) { \
2775 /* Check if there is already a pointer to a Python object in the \
2776 OOR data that we can use. */ \
2777 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2778 if (data) { \
2779 target = data->m_obj; \
2780 if (target) \
2781 Py_INCREF(target); \
2782 } \
2783 /* Otherwise make a new wrapper for it the old fashioned way and \
2784 give it the OOR treatment */ \
2785 if (! target) { \
2786 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2787 if (target) \
2788 source->SetClientObject(new wxPyOORClientData(target)); \
2789 } \
2790 } else { /* source was NULL so return None. */ \
2791 Py_INCREF(Py_None); target = Py_None; \
2792 } \
2793 return target; \
2794 } \
2795
2796
2797 wxPyMake_TEMPLATE(wxGridCellRenderer)
2798 wxPyMake_TEMPLATE(wxGridCellEditor)
2799 wxPyMake_TEMPLATE(wxGridCellAttr)
2800 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2801 wxPyMake_TEMPLATE(wxGridTableBase)
2802
2803
2804
2805 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2806 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2807 wxGridCellAttr* rval = NULL; \
2808 bool found; \
2809 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2810 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2811 PyObject* ro; \
2812 wxGridCellAttr* ptr; \
2813 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2814 if (ro) { \
2815 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2816 rval = ptr; \
2817 Py_DECREF(ro); \
2818 } \
2819 } \
2820 wxPyEndBlockThreads(blocked); \
2821 if (! found) \
2822 rval = PCLASS::CBNAME(a, b, c); \
2823 return rval; \
2824 }
2825
2826
2827 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2828 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2830 bool found; \
2831 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2832 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2833 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2834 Py_DECREF(obj); \
2835 } \
2836 wxPyEndBlockThreads(blocked); \
2837 if (! found) \
2838 PCLASS::CBNAME(attr, a, b); \
2839 }
2840
2841
2842
2843 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2844 void CBNAME(wxGridCellAttr *attr, int val) { \
2845 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2846 bool found; \
2847 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2848 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2849 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2850 Py_DECREF(obj); \
2851 } \
2852 wxPyEndBlockThreads(blocked); \
2853 if (! found) \
2854 PCLASS::CBNAME(attr, val); \
2855 }
2856
2857
2858
2859 #define PYCALLBACK_INT__pure(CBNAME) \
2860 int CBNAME() { \
2861 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2862 int rval = 0; \
2863 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2864 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2865 wxPyEndBlockThreads(blocked); \
2866 return rval; \
2867 }
2868
2869
2870
2871 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2872 bool CBNAME(int a, int b) { \
2873 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2874 bool rval = 0; \
2875 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2876 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2877 wxPyEndBlockThreads(blocked); \
2878 return rval; \
2879 }
2880
2881
2882 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2883 wxString CBNAME(int a, int b) { \
2884 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2885 wxString rval; \
2886 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2887 PyObject* ro; \
2888 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2889 if (ro) { \
2890 rval = Py2wxString(ro); \
2891 Py_DECREF(ro); \
2892 } \
2893 } \
2894 wxPyEndBlockThreads(blocked); \
2895 return rval; \
2896 }
2897
2898
2899 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2900 void CBNAME(int a, int b, const wxString& c) { \
2901 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2902 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2903 PyObject* s = wx2PyString(c); \
2904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2905 Py_DECREF(s); \
2906 } \
2907 wxPyEndBlockThreads(blocked); \
2908 }
2909
2910
2911 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2912 wxString CBNAME(int a, int b) { \
2913 bool found; \
2914 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2915 wxString rval; \
2916 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2917 PyObject* ro; \
2918 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2919 if (ro) { \
2920 rval = Py2wxString(ro); \
2921 Py_DECREF(ro); \
2922 } \
2923 } \
2924 wxPyEndBlockThreads(blocked); \
2925 if (! found) \
2926 rval = PCLASS::CBNAME(a, b); \
2927 return rval; \
2928 }
2929
2930
2931 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2932 bool CBNAME(int a, int b, const wxString& c) { \
2933 bool rval = 0; \
2934 bool found; \
2935 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2936 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2937 PyObject* s = wx2PyString(c); \
2938 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2939 Py_DECREF(s); \
2940 } \
2941 wxPyEndBlockThreads(blocked); \
2942 if (! found) \
2943 rval = PCLASS::CBNAME(a,b,c); \
2944 return rval; \
2945 }
2946
2947
2948
2949
2950 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2951 long CBNAME(int a, int b) { \
2952 long rval; \
2953 bool found; \
2954 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2955 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2956 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2957 wxPyEndBlockThreads(blocked); \
2958 if (! found) \
2959 rval = PCLASS::CBNAME(a,b); \
2960 return rval; \
2961 }
2962
2963
2964 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2965 bool CBNAME(int a, int b) { \
2966 bool rval = 0; \
2967 bool found; \
2968 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2969 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2970 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2971 wxPyEndBlockThreads(blocked); \
2972 if (! found) \
2973 rval = PCLASS::CBNAME(a,b); \
2974 return rval; \
2975 }
2976
2977
2978
2979 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2980 double CBNAME(int a, int b) { \
2981 bool found; \
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2983 double rval; \
2984 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2985 PyObject* ro; \
2986 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2987 if (ro) { \
2988 PyObject* str = PyObject_Str(ro); \
2989 rval = PyFloat_AsDouble(str); \
2990 Py_DECREF(ro); Py_DECREF(str); \
2991 } \
2992 } \
2993 wxPyEndBlockThreads(blocked); \
2994 if (! found) \
2995 rval = PCLASS::CBNAME(a, b); \
2996 return rval; \
2997 }
2998
2999
3000
3001 #define PYCALLBACK__(PCLASS, CBNAME) \
3002 void CBNAME() { \
3003 bool found; \
3004 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3005 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3006 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3007 wxPyEndBlockThreads(blocked); \
3008 if (! found) \
3009 PCLASS::CBNAME(); \
3010 }
3011
3012
3013
3014 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3015 bool CBNAME(size_t a, size_t b) { \
3016 bool rval = 0; \
3017 bool found; \
3018 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3019 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3020 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3021 wxPyEndBlockThreads(blocked); \
3022 if (! found) \
3023 rval = PCLASS::CBNAME(a,b); \
3024 return rval; \
3025 }
3026
3027
3028
3029 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3030 bool CBNAME(size_t a) { \
3031 bool rval = 0; \
3032 bool found; \
3033 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3034 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3035 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3036 wxPyEndBlockThreads(blocked); \
3037 if (! found) \
3038 rval = PCLASS::CBNAME(a); \
3039 return rval; \
3040 }
3041
3042
3043 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3044 wxString CBNAME(int a) { \
3045 bool found; \
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3047 wxString rval; \
3048 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3049 PyObject* ro; \
3050 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3051 if (ro) { \
3052 rval = Py2wxString(ro); \
3053 Py_DECREF(ro); \
3054 } \
3055 } \
3056 wxPyEndBlockThreads(blocked); \
3057 if (! found) \
3058 rval = PCLASS::CBNAME(a); \
3059 return rval; \
3060 }
3061
3062
3063 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3064 void CBNAME(int a, const wxString& c) { \
3065 bool found; \
3066 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3067 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3068 PyObject* s = wx2PyString(c); \
3069 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3070 Py_DECREF(s); \
3071 } \
3072 wxPyEndBlockThreads(blocked); \
3073 if (! found) \
3074 PCLASS::CBNAME(a,c); \
3075 }
3076
3077
3078
3079
3080 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3081 bool CBNAME() { \
3082 bool rval = 0; \
3083 bool found; \
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3085 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3086 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3087 wxPyEndBlockThreads(blocked); \
3088 if (! found) \
3089 rval = PCLASS::CBNAME(); \
3090 return rval; \
3091 }
3092
3093
3094
3095 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3096 void CBNAME(size_t a, int b) { \
3097 bool found; \
3098 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3099 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3100 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3101 wxPyEndBlockThreads(blocked); \
3102 if (! found) \
3103 PCLASS::CBNAME(a,b); \
3104 }
3105
3106
3107
3108
3109 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3110 void CBNAME(int a, int b, long c) { \
3111 bool found; \
3112 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3113 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3114 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3115 wxPyEndBlockThreads(blocked); \
3116 if (! found) \
3117 PCLASS::CBNAME(a,b,c); \
3118 }
3119
3120
3121
3122
3123 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3124 void CBNAME(int a, int b, double c) { \
3125 bool found; \
3126 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3127 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3128 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3129 wxPyEndBlockThreads(blocked); \
3130 if (! found) \
3131 PCLASS::CBNAME(a,b,c); \
3132 }
3133
3134
3135
3136 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3137 void CBNAME(int a, int b, bool c) { \
3138 bool found; \
3139 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3140 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3141 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3142 wxPyEndBlockThreads(blocked); \
3143 if (! found) \
3144 PCLASS::CBNAME(a,b,c); \
3145 }
3146
3147
3148
3149
3150
3151 SWIGINTERN swig_type_info*
3152 SWIG_pchar_descriptor()
3153 {
3154 static int init = 0;
3155 static swig_type_info* info = 0;
3156 if (!init) {
3157 info = SWIG_TypeQuery("_p_char");
3158 init = 1;
3159 }
3160 return info;
3161 }
3162
3163
3164 SWIGINTERNINLINE PyObject *
3165 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3166 {
3167 if (carray) {
3168 if (size > INT_MAX) {
3169 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3170 return pchar_descriptor ?
3171 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3172 } else {
3173 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3174 }
3175 } else {
3176 return SWIG_Py_Void();
3177 }
3178 }
3179
3180
3181 SWIGINTERNINLINE PyObject *
3182 SWIG_FromCharPtr(const char *cptr)
3183 {
3184 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3185 }
3186
3187
3188 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3189 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3190 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3191 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3192 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3193 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3194 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3195 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3196 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3197 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3198
3199
3200 #define SWIG_From_long PyInt_FromLong
3201
3202
3203 SWIGINTERNINLINE PyObject *
3204 SWIG_From_int (int value)
3205 {
3206 return SWIG_From_long (value);
3207 }
3208
3209 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3210 if (!self->GetClientObject())
3211 self->SetClientObject(new wxPyOORClientData(_self));
3212 }
3213 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3214 }
3215
3216 #include <limits.h>
3217 #ifndef LLONG_MIN
3218 # define LLONG_MIN LONG_LONG_MIN
3219 #endif
3220 #ifndef LLONG_MAX
3221 # define LLONG_MAX LONG_LONG_MAX
3222 #endif
3223 #ifndef ULLONG_MAX
3224 # define ULLONG_MAX ULONG_LONG_MAX
3225 #endif
3226
3227
3228 SWIGINTERN int
3229 SWIG_AsVal_long (PyObject* obj, long* val)
3230 {
3231 if (PyNumber_Check(obj)) {
3232 if (val) *val = PyInt_AsLong(obj);
3233 return SWIG_OK;
3234 }
3235 return SWIG_TypeError;
3236 }
3237
3238
3239 SWIGINTERN int
3240 SWIG_AsVal_int (PyObject * obj, int *val)
3241 {
3242 long v;
3243 int res = SWIG_AsVal_long (obj, &v);
3244 if (SWIG_IsOK(res)) {
3245 if ((v < INT_MIN || v > INT_MAX)) {
3246 return SWIG_OverflowError;
3247 } else {
3248 if (val) *val = static_cast< int >(v);
3249 }
3250 }
3251 return res;
3252 }
3253
3254
3255 SWIGINTERN int
3256 SWIG_AsVal_bool (PyObject *obj, bool *val)
3257 {
3258 if (obj == Py_True) {
3259 if (val) *val = true;
3260 return SWIG_OK;
3261 } else if (obj == Py_False) {
3262 if (val) *val = false;
3263 return SWIG_OK;
3264 } else {
3265 long v = 0;
3266 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3267 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3268 return res;
3269 }
3270 }
3271
3272
3273 class wxPyGridCellRenderer : public wxGridCellRenderer
3274 {
3275 public:
3276 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3277
3278 // Implement Python callback aware virtual methods
3279 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3280 wxDC& dc, const wxRect& rect,
3281 int row, int col, bool isSelected) {
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3284 PyObject* go = wxPyMake_wxObject(&grid,false);
3285 PyObject* dco = wxPyMake_wxObject(&dc,false);
3286 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3287 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3288
3289 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3290 row, col, isSelected));
3291 Py_DECREF(go);
3292 Py_DECREF(ao);
3293 Py_DECREF(dco);
3294 Py_DECREF(ro);
3295 }
3296 wxPyEndBlockThreads(blocked);
3297 }
3298
3299 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3300 int row, int col) {
3301 wxSize rval;
3302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3303 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3304 PyObject* ro;
3305 wxSize* ptr;
3306 PyObject* go = wxPyMake_wxObject(&grid,false);
3307 PyObject* dco = wxPyMake_wxObject(&dc,false);
3308 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3309
3310 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3311 go, ao, dco,
3312 row, col));
3313 Py_DECREF(go);
3314 Py_DECREF(ao);
3315 Py_DECREF(dco);
3316
3317 if (ro) {
3318 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3319 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3320 rval = *ptr;
3321 }
3322 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3323 PyErr_Clear(); // Clear the exception left over from wxPyConvertSwigPtr
3324 PyObject* o1 = PySequence_GetItem(ro, 0);
3325 PyObject* o2 = PySequence_GetItem(ro, 1);
3326 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3327 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3328 else
3329 PyErr_SetString(PyExc_TypeError, errmsg);
3330 Py_DECREF(o1);
3331 Py_DECREF(o2);
3332 }
3333 else {
3334 PyErr_SetString(PyExc_TypeError, errmsg);
3335 }
3336 Py_DECREF(ro);
3337 }
3338 }
3339 wxPyEndBlockThreads(blocked);
3340 return rval;
3341 }
3342
3343
3344 wxGridCellRenderer *Clone() const {
3345 wxGridCellRenderer* rval = NULL;
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3348 PyObject* ro;
3349 wxGridCellRenderer* ptr;
3350 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3351 if (ro) {
3352 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3353 rval = ptr;
3354 Py_DECREF(ro);
3355 }
3356 }
3357 wxPyEndBlockThreads(blocked);
3358 return rval;
3359 }
3360
3361 DEC_PYCALLBACK__STRING(SetParameters);
3362
3363 PYPRIVATE;
3364 };
3365
3366 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3367
3368
3369
3370 class wxPyGridCellEditor : public wxGridCellEditor
3371 {
3372 public:
3373 wxPyGridCellEditor() : wxGridCellEditor() {}
3374
3375 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3376 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3377 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3378 PyObject* po = wxPyMake_wxObject(parent,false);
3379 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3380
3381 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3382 Py_DECREF(po);
3383 Py_DECREF(eo);
3384 }
3385 wxPyEndBlockThreads(blocked);
3386 }
3387
3388
3389 void BeginEdit(int row, int col, wxGrid* grid) {
3390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3391 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3392 PyObject* go = wxPyMake_wxObject(grid,false);
3393 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3394 Py_DECREF(go);
3395 }
3396 wxPyEndBlockThreads(blocked);
3397 }
3398
3399
3400 bool EndEdit(int row, int col, wxGrid* grid) {
3401 bool rv = false;
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3404 PyObject* go = wxPyMake_wxObject(grid,false);
3405 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3406 Py_DECREF(go);
3407 }
3408 wxPyEndBlockThreads(blocked);
3409 return rv;
3410 }
3411
3412
3413 wxGridCellEditor* Clone() const {
3414 wxGridCellEditor* rval = NULL;
3415 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3416 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3417 PyObject* ro;
3418 wxGridCellEditor* ptr;
3419 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3420 if (ro) {
3421 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3422 rval = ptr;
3423 Py_DECREF(ro);
3424 }
3425 }
3426 wxPyEndBlockThreads(blocked);
3427 return rval;
3428 }
3429
3430
3431 void Show(bool show, wxGridCellAttr *attr) {
3432 bool found;
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3435 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3436 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3437 Py_DECREF(ao);
3438 }
3439 wxPyEndBlockThreads(blocked);
3440 if (! found)
3441 wxGridCellEditor::Show(show, attr);
3442 }
3443
3444
3445 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3446 bool found;
3447 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3448 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3449 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3450 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3451
3452 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3453
3454 Py_DECREF(ro);
3455 Py_DECREF(ao);
3456 }
3457 wxPyEndBlockThreads(blocked);
3458 if (! found)
3459 wxGridCellEditor::PaintBackground(rectCell, attr);
3460 }
3461
3462
3463 DEC_PYCALLBACK___pure(Reset);
3464 DEC_PYCALLBACK__constany(SetSize, wxRect);
3465 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3466 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3467 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3468 DEC_PYCALLBACK__(StartingClick);
3469 DEC_PYCALLBACK__(Destroy);
3470 DEC_PYCALLBACK__STRING(SetParameters);
3471 DEC_PYCALLBACK_STRING__constpure(GetValue);
3472
3473 PYPRIVATE;
3474 };
3475
3476
3477 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3478 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3479 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3480 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3481 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3482 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3483 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3484 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3485 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3486
3487
3488 static const wxString wxPyOneString(_T("1"));
3489 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3490 if (!self->GetClientObject())
3491 self->SetClientObject(new wxPyOORClientData(_self));
3492 }
3493 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3494 }
3495 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3496 if (!self->GetClientObject())
3497 self->SetClientObject(new wxPyOORClientData(_self));
3498 }
3499
3500 SWIGINTERN int
3501 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3502 {
3503 long v = 0;
3504 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3505 return SWIG_TypeError;
3506 }
3507 else if (val)
3508 *val = (unsigned long)v;
3509 return SWIG_OK;
3510 }
3511
3512
3513 SWIGINTERNINLINE int
3514 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3515 {
3516 unsigned long v;
3517 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3518 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3519 return res;
3520 }
3521
3522
3523 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3524 {
3525 public:
3526 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3527
3528 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3529 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3530 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3531 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3537 if (!self->GetClientObject())
3538 self->SetClientObject(new wxPyOORClientData(_self));
3539 }
3540
3541 #define SWIG_From_double PyFloat_FromDouble
3542
3543
3544 SWIGINTERN int
3545 SWIG_AsVal_double (PyObject *obj, double* val)
3546 {
3547 if (PyNumber_Check(obj)) {
3548 if (val) *val = PyFloat_AsDouble(obj);
3549 return SWIG_OK;
3550 }
3551 return SWIG_TypeError;
3552 }
3553
3554
3555 class wxPyGridTableBase : public wxGridTableBase
3556 {
3557 public:
3558 wxPyGridTableBase() : wxGridTableBase() {}
3559
3560 PYCALLBACK_INT__pure(GetNumberRows);
3561 PYCALLBACK_INT__pure(GetNumberCols);
3562 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3563 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3564 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3565 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3566 PYCALLBACK__(wxGridTableBase, Clear);
3567 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3568 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3569 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3570 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3571 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3572 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3573 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3574 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3575 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3576 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3577 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3578 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3579 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3580 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3581 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3582
3583
3584 wxString GetValue(int row, int col) {
3585 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3586 wxString rval;
3587 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3588 PyObject* ro;
3589 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3590 if (ro) {
3591 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3592 PyObject* old = ro;
3593 ro = PyObject_Str(ro);
3594 Py_DECREF(old);
3595 }
3596 rval = Py2wxString(ro);
3597 Py_DECREF(ro);
3598 }
3599 }
3600 wxPyEndBlockThreads(blocked);
3601 return rval;
3602 }
3603
3604 void SetValue(int row, int col, const wxString& val) {
3605 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3606 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3607 PyObject* s = wx2PyString(val);
3608 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3609 Py_DECREF(s);
3610 }
3611 wxPyEndBlockThreads(blocked);
3612 }
3613
3614
3615 // Map the Get/Set methods for the standard non-string types to
3616 // the GetValue and SetValue python methods.
3617 long GetValueAsLong( int row, int col ) {
3618 long rval = 0;
3619 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3620 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3621 PyObject* ro;
3622 PyObject* num;
3623 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3624 if (ro && PyNumber_Check(ro)) {
3625 num = PyNumber_Int(ro);
3626 if (num) {
3627 rval = PyInt_AsLong(num);
3628 Py_DECREF(num);
3629 }
3630 Py_DECREF(ro);
3631 }
3632 }
3633 wxPyEndBlockThreads(blocked);
3634 return rval;
3635 }
3636
3637 double GetValueAsDouble( int row, int col ) {
3638 double rval = 0.0;
3639 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3640 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3641 PyObject* ro;
3642 PyObject* num;
3643 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3644 if (ro && PyNumber_Check(ro)) {
3645 num = PyNumber_Float(ro);
3646 if (num) {
3647 rval = PyFloat_AsDouble(num);
3648 Py_DECREF(num);
3649 }
3650 Py_DECREF(ro);
3651 }
3652 }
3653 wxPyEndBlockThreads(blocked);
3654 return rval;
3655 }
3656
3657 bool GetValueAsBool( int row, int col ) {
3658 return (bool)GetValueAsLong(row, col);
3659 }
3660
3661 void SetValueAsLong( int row, int col, long value ) {
3662 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3663 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3664 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3665 }
3666 wxPyEndBlockThreads(blocked);
3667 }
3668
3669 void SetValueAsDouble( int row, int col, double value ) {
3670 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3671 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3672 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3673 }
3674 wxPyEndBlockThreads(blocked);
3675 }
3676
3677 void SetValueAsBool( int row, int col, bool value ) {
3678 SetValueAsLong( row, col, (long)value );
3679 }
3680
3681
3682 PYPRIVATE;
3683 };
3684
3685 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3686
3687 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3688
3689 if (source == Py_None) {
3690 **obj = wxGridCellCoords(-1,-1);
3691 return true;
3692 }
3693
3694 // If source is an object instance then it may already be the right type
3695 if (wxPySwigInstance_Check(source)) {
3696 wxGridCellCoords* ptr;
3697 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3698 goto error;
3699 *obj = ptr;
3700 return true;
3701 }
3702 // otherwise a 2-tuple of integers is expected
3703 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3704 PyObject* o1 = PySequence_GetItem(source, 0);
3705 PyObject* o2 = PySequence_GetItem(source, 1);
3706 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3707 Py_DECREF(o1);
3708 Py_DECREF(o2);
3709 goto error;
3710 }
3711 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3712 Py_DECREF(o1);
3713 Py_DECREF(o2);
3714 return true;
3715 }
3716
3717 error:
3718 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3719 return false;
3720 }
3721
3722
3723 bool wxGridCellCoords_typecheck(PyObject* source) {
3724 void* ptr;
3725
3726 if (wxPySwigInstance_Check(source) &&
3727 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3728 return true;
3729
3730 PyErr_Clear();
3731 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3732 return true;
3733
3734 return false;
3735 }
3736
3737
3738 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3739 {
3740 PyObject* list = PyList_New(0);
3741 size_t idx;
3742 for (idx = 0; idx < source.GetCount(); idx += 1) {
3743 wxGridCellCoords& coord = source.Item(idx);
3744 PyObject* tup = PyTuple_New(2);
3745 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3746 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3747 PyList_Append(list, tup);
3748 Py_DECREF(tup);
3749 }
3750 return list;
3751 }
3752
3753 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3754 wxGridCellCoords temp, *obj = &temp;
3755 if ( other == Py_None ) return false;
3756 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3757 PyErr_Clear();
3758 return false;
3759 }
3760 return self->operator==(*obj);
3761 }
3762 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3763 wxGridCellCoords temp, *obj = &temp;
3764 if ( other == Py_None ) return true;
3765 if ( ! wxGridCellCoords_helper(other, &obj)) {
3766 PyErr_Clear();
3767 return true;
3768 }
3769 return self->operator!=(*obj);
3770 }
3771 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3772 PyObject* tup = PyTuple_New(2);
3773 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3774 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3775 return tup;
3776 }
3777
3778 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3779
3780 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3781 wxGridCellCoords rv;
3782 self->XYToCell(x, y, rv);
3783 return rv;
3784 }
3785 #ifdef __cplusplus
3786 extern "C" {
3787 #endif
3788 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3789 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3790 return 1;
3791 }
3792
3793
3794 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3795 PyObject *pyobj = 0;
3796
3797 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3798 return pyobj;
3799 }
3800
3801
3802 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3803 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3804 return 1;
3805 }
3806
3807
3808 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3809 PyObject *pyobj = 0;
3810
3811 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3812 return pyobj;
3813 }
3814
3815
3816 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3817 PyObject *resultobj = 0;
3818 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3819 PyObject *arg2 = (PyObject *) 0 ;
3820 void *argp1 = 0 ;
3821 int res1 = 0 ;
3822 PyObject * obj0 = 0 ;
3823 PyObject * obj1 = 0 ;
3824 char * kwnames[] = {
3825 (char *) "self",(char *) "_self", NULL
3826 };
3827
3828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3830 if (!SWIG_IsOK(res1)) {
3831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3832 }
3833 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3834 arg2 = obj1;
3835 {
3836 PyThreadState* __tstate = wxPyBeginAllowThreads();
3837 wxGridCellWorker__setOORInfo(arg1,arg2);
3838 wxPyEndAllowThreads(__tstate);
3839 if (PyErr_Occurred()) SWIG_fail;
3840 }
3841 resultobj = SWIG_Py_Void();
3842 return resultobj;
3843 fail:
3844 return NULL;
3845 }
3846
3847
3848 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3849 PyObject *resultobj = 0;
3850 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3851 void *argp1 = 0 ;
3852 int res1 = 0 ;
3853 PyObject *swig_obj[1] ;
3854
3855 if (!args) SWIG_fail;
3856 swig_obj[0] = args;
3857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3858 if (!SWIG_IsOK(res1)) {
3859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3860 }
3861 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3862 {
3863 PyThreadState* __tstate = wxPyBeginAllowThreads();
3864 delete_wxGridCellWorker(arg1);
3865
3866 wxPyEndAllowThreads(__tstate);
3867 if (PyErr_Occurred()) SWIG_fail;
3868 }
3869 resultobj = SWIG_Py_Void();
3870 return resultobj;
3871 fail:
3872 return NULL;
3873 }
3874
3875
3876 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3877 PyObject *resultobj = 0;
3878 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3879 wxString *arg2 = 0 ;
3880 void *argp1 = 0 ;
3881 int res1 = 0 ;
3882 bool temp2 = false ;
3883 PyObject * obj0 = 0 ;
3884 PyObject * obj1 = 0 ;
3885 char * kwnames[] = {
3886 (char *) "self",(char *) "params", NULL
3887 };
3888
3889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3891 if (!SWIG_IsOK(res1)) {
3892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3893 }
3894 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3895 {
3896 arg2 = wxString_in_helper(obj1);
3897 if (arg2 == NULL) SWIG_fail;
3898 temp2 = true;
3899 }
3900 {
3901 PyThreadState* __tstate = wxPyBeginAllowThreads();
3902 (arg1)->SetParameters((wxString const &)*arg2);
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 resultobj = SWIG_Py_Void();
3907 {
3908 if (temp2)
3909 delete arg2;
3910 }
3911 return resultobj;
3912 fail:
3913 {
3914 if (temp2)
3915 delete arg2;
3916 }
3917 return NULL;
3918 }
3919
3920
3921 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3922 PyObject *resultobj = 0;
3923 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3924 void *argp1 = 0 ;
3925 int res1 = 0 ;
3926 PyObject *swig_obj[1] ;
3927
3928 if (!args) SWIG_fail;
3929 swig_obj[0] = args;
3930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3931 if (!SWIG_IsOK(res1)) {
3932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3933 }
3934 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3935 {
3936 PyThreadState* __tstate = wxPyBeginAllowThreads();
3937 (arg1)->IncRef();
3938 wxPyEndAllowThreads(__tstate);
3939 if (PyErr_Occurred()) SWIG_fail;
3940 }
3941 resultobj = SWIG_Py_Void();
3942 return resultobj;
3943 fail:
3944 return NULL;
3945 }
3946
3947
3948 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3949 PyObject *resultobj = 0;
3950 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3951 void *argp1 = 0 ;
3952 int res1 = 0 ;
3953 PyObject *swig_obj[1] ;
3954
3955 if (!args) SWIG_fail;
3956 swig_obj[0] = args;
3957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3958 if (!SWIG_IsOK(res1)) {
3959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3960 }
3961 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3962 {
3963 PyThreadState* __tstate = wxPyBeginAllowThreads();
3964 (arg1)->DecRef();
3965 wxPyEndAllowThreads(__tstate);
3966 if (PyErr_Occurred()) SWIG_fail;
3967 }
3968 resultobj = SWIG_Py_Void();
3969 return resultobj;
3970 fail:
3971 return NULL;
3972 }
3973
3974
3975 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3976 PyObject *obj;
3977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3978 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3979 return SWIG_Py_Void();
3980 }
3981
3982 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj = 0;
3984 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3985 wxGrid *arg2 = 0 ;
3986 wxGridCellAttr *arg3 = 0 ;
3987 wxDC *arg4 = 0 ;
3988 wxRect *arg5 = 0 ;
3989 int arg6 ;
3990 int arg7 ;
3991 bool arg8 ;
3992 void *argp1 = 0 ;
3993 int res1 = 0 ;
3994 void *argp2 = 0 ;
3995 int res2 = 0 ;
3996 void *argp3 = 0 ;
3997 int res3 = 0 ;
3998 void *argp4 = 0 ;
3999 int res4 = 0 ;
4000 wxRect temp5 ;
4001 int val6 ;
4002 int ecode6 = 0 ;
4003 int val7 ;
4004 int ecode7 = 0 ;
4005 bool val8 ;
4006 int ecode8 = 0 ;
4007 PyObject * obj0 = 0 ;
4008 PyObject * obj1 = 0 ;
4009 PyObject * obj2 = 0 ;
4010 PyObject * obj3 = 0 ;
4011 PyObject * obj4 = 0 ;
4012 PyObject * obj5 = 0 ;
4013 PyObject * obj6 = 0 ;
4014 PyObject * obj7 = 0 ;
4015 char * kwnames[] = {
4016 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4017 };
4018
4019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4021 if (!SWIG_IsOK(res1)) {
4022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4023 }
4024 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4026 if (!SWIG_IsOK(res2)) {
4027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4028 }
4029 if (!argp2) {
4030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4031 }
4032 arg2 = reinterpret_cast< wxGrid * >(argp2);
4033 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4034 if (!SWIG_IsOK(res3)) {
4035 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4036 }
4037 if (!argp3) {
4038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4039 }
4040 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4041 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4042 if (!SWIG_IsOK(res4)) {
4043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4044 }
4045 if (!argp4) {
4046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4047 }
4048 arg4 = reinterpret_cast< wxDC * >(argp4);
4049 {
4050 arg5 = &temp5;
4051 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4052 }
4053 ecode6 = SWIG_AsVal_int(obj5, &val6);
4054 if (!SWIG_IsOK(ecode6)) {
4055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4056 }
4057 arg6 = static_cast< int >(val6);
4058 ecode7 = SWIG_AsVal_int(obj6, &val7);
4059 if (!SWIG_IsOK(ecode7)) {
4060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4061 }
4062 arg7 = static_cast< int >(val7);
4063 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4064 if (!SWIG_IsOK(ecode8)) {
4065 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4066 }
4067 arg8 = static_cast< bool >(val8);
4068 {
4069 PyThreadState* __tstate = wxPyBeginAllowThreads();
4070 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 resultobj = SWIG_Py_Void();
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj = 0;
4083 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4084 wxGrid *arg2 = 0 ;
4085 wxGridCellAttr *arg3 = 0 ;
4086 wxDC *arg4 = 0 ;
4087 int arg5 ;
4088 int arg6 ;
4089 wxSize result;
4090 void *argp1 = 0 ;
4091 int res1 = 0 ;
4092 void *argp2 = 0 ;
4093 int res2 = 0 ;
4094 void *argp3 = 0 ;
4095 int res3 = 0 ;
4096 void *argp4 = 0 ;
4097 int res4 = 0 ;
4098 int val5 ;
4099 int ecode5 = 0 ;
4100 int val6 ;
4101 int ecode6 = 0 ;
4102 PyObject * obj0 = 0 ;
4103 PyObject * obj1 = 0 ;
4104 PyObject * obj2 = 0 ;
4105 PyObject * obj3 = 0 ;
4106 PyObject * obj4 = 0 ;
4107 PyObject * obj5 = 0 ;
4108 char * kwnames[] = {
4109 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4110 };
4111
4112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4114 if (!SWIG_IsOK(res1)) {
4115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4116 }
4117 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4119 if (!SWIG_IsOK(res2)) {
4120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4121 }
4122 if (!argp2) {
4123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4124 }
4125 arg2 = reinterpret_cast< wxGrid * >(argp2);
4126 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4127 if (!SWIG_IsOK(res3)) {
4128 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4129 }
4130 if (!argp3) {
4131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4132 }
4133 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4134 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4135 if (!SWIG_IsOK(res4)) {
4136 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4137 }
4138 if (!argp4) {
4139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4140 }
4141 arg4 = reinterpret_cast< wxDC * >(argp4);
4142 ecode5 = SWIG_AsVal_int(obj4, &val5);
4143 if (!SWIG_IsOK(ecode5)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4145 }
4146 arg5 = static_cast< int >(val5);
4147 ecode6 = SWIG_AsVal_int(obj5, &val6);
4148 if (!SWIG_IsOK(ecode6)) {
4149 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4150 }
4151 arg6 = static_cast< int >(val6);
4152 {
4153 PyThreadState* __tstate = wxPyBeginAllowThreads();
4154 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4159 return resultobj;
4160 fail:
4161 return NULL;
4162 }
4163
4164
4165 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4166 PyObject *resultobj = 0;
4167 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4168 wxGridCellRenderer *result = 0 ;
4169 void *argp1 = 0 ;
4170 int res1 = 0 ;
4171 PyObject *swig_obj[1] ;
4172
4173 if (!args) SWIG_fail;
4174 swig_obj[0] = args;
4175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4176 if (!SWIG_IsOK(res1)) {
4177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4178 }
4179 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4180 {
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 {
4187 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4188 }
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4196 PyObject *obj;
4197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4199 return SWIG_Py_Void();
4200 }
4201
4202 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4203 PyObject *resultobj = 0;
4204 wxPyGridCellRenderer *result = 0 ;
4205
4206 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj = 0;
4222 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4223 PyObject *arg2 = (PyObject *) 0 ;
4224 PyObject *arg3 = (PyObject *) 0 ;
4225 void *argp1 = 0 ;
4226 int res1 = 0 ;
4227 PyObject * obj0 = 0 ;
4228 PyObject * obj1 = 0 ;
4229 PyObject * obj2 = 0 ;
4230 char * kwnames[] = {
4231 (char *) "self",(char *) "self",(char *) "_class", NULL
4232 };
4233
4234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4236 if (!SWIG_IsOK(res1)) {
4237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4238 }
4239 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4240 arg2 = obj1;
4241 arg3 = obj2;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 (arg1)->_setCallbackInfo(arg2,arg3);
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_Py_Void();
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = 0;
4257 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4258 wxString *arg2 = 0 ;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 bool temp2 = false ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 char * kwnames[] = {
4265 (char *) "self",(char *) "params", NULL
4266 };
4267
4268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4270 if (!SWIG_IsOK(res1)) {
4271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4272 }
4273 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4274 {
4275 arg2 = wxString_in_helper(obj1);
4276 if (arg2 == NULL) SWIG_fail;
4277 temp2 = true;
4278 }
4279 {
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 (arg1)->SetParameters((wxString const &)*arg2);
4282 wxPyEndAllowThreads(__tstate);
4283 if (PyErr_Occurred()) SWIG_fail;
4284 }
4285 resultobj = SWIG_Py_Void();
4286 {
4287 if (temp2)
4288 delete arg2;
4289 }
4290 return resultobj;
4291 fail:
4292 {
4293 if (temp2)
4294 delete arg2;
4295 }
4296 return NULL;
4297 }
4298
4299
4300 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *obj;
4302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4304 return SWIG_Py_Void();
4305 }
4306
4307 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 return SWIG_Python_InitShadowInstance(args);
4309 }
4310
4311 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4312 PyObject *resultobj = 0;
4313 wxGridCellStringRenderer *result = 0 ;
4314
4315 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330 PyObject *obj;
4331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4332 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4333 return SWIG_Py_Void();
4334 }
4335
4336 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 return SWIG_Python_InitShadowInstance(args);
4338 }
4339
4340 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4341 PyObject *resultobj = 0;
4342 wxGridCellNumberRenderer *result = 0 ;
4343
4344 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4352 return resultobj;
4353 fail:
4354 return NULL;
4355 }
4356
4357
4358 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4359 PyObject *obj;
4360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4361 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4362 return SWIG_Py_Void();
4363 }
4364
4365 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4366 return SWIG_Python_InitShadowInstance(args);
4367 }
4368
4369 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj = 0;
4371 int arg1 = (int) -1 ;
4372 int arg2 = (int) -1 ;
4373 wxGridCellFloatRenderer *result = 0 ;
4374 int val1 ;
4375 int ecode1 = 0 ;
4376 int val2 ;
4377 int ecode2 = 0 ;
4378 PyObject * obj0 = 0 ;
4379 PyObject * obj1 = 0 ;
4380 char * kwnames[] = {
4381 (char *) "width",(char *) "precision", NULL
4382 };
4383
4384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4385 if (obj0) {
4386 ecode1 = SWIG_AsVal_int(obj0, &val1);
4387 if (!SWIG_IsOK(ecode1)) {
4388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4389 }
4390 arg1 = static_cast< int >(val1);
4391 }
4392 if (obj1) {
4393 ecode2 = SWIG_AsVal_int(obj1, &val2);
4394 if (!SWIG_IsOK(ecode2)) {
4395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4396 }
4397 arg2 = static_cast< int >(val2);
4398 }
4399 {
4400 PyThreadState* __tstate = wxPyBeginAllowThreads();
4401 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4402 wxPyEndAllowThreads(__tstate);
4403 if (PyErr_Occurred()) SWIG_fail;
4404 }
4405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4415 int result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4425 }
4426 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 resultobj = SWIG_From_int(static_cast< int >(result));
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj = 0;
4442 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4443 int arg2 ;
4444 void *argp1 = 0 ;
4445 int res1 = 0 ;
4446 int val2 ;
4447 int ecode2 = 0 ;
4448 PyObject * obj0 = 0 ;
4449 PyObject * obj1 = 0 ;
4450 char * kwnames[] = {
4451 (char *) "self",(char *) "width", NULL
4452 };
4453
4454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4458 }
4459 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4460 ecode2 = SWIG_AsVal_int(obj1, &val2);
4461 if (!SWIG_IsOK(ecode2)) {
4462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4463 }
4464 arg2 = static_cast< int >(val2);
4465 {
4466 PyThreadState* __tstate = wxPyBeginAllowThreads();
4467 (arg1)->SetWidth(arg2);
4468 wxPyEndAllowThreads(__tstate);
4469 if (PyErr_Occurred()) SWIG_fail;
4470 }
4471 resultobj = SWIG_Py_Void();
4472 return resultobj;
4473 fail:
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4479 PyObject *resultobj = 0;
4480 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4481 int result;
4482 void *argp1 = 0 ;
4483 int res1 = 0 ;
4484 PyObject *swig_obj[1] ;
4485
4486 if (!args) SWIG_fail;
4487 swig_obj[0] = args;
4488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4489 if (!SWIG_IsOK(res1)) {
4490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4491 }
4492 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4493 {
4494 PyThreadState* __tstate = wxPyBeginAllowThreads();
4495 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4496 wxPyEndAllowThreads(__tstate);
4497 if (PyErr_Occurred()) SWIG_fail;
4498 }
4499 resultobj = SWIG_From_int(static_cast< int >(result));
4500 return resultobj;
4501 fail:
4502 return NULL;
4503 }
4504
4505
4506 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4507 PyObject *resultobj = 0;
4508 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4509 int arg2 ;
4510 void *argp1 = 0 ;
4511 int res1 = 0 ;
4512 int val2 ;
4513 int ecode2 = 0 ;
4514 PyObject * obj0 = 0 ;
4515 PyObject * obj1 = 0 ;
4516 char * kwnames[] = {
4517 (char *) "self",(char *) "precision", NULL
4518 };
4519
4520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4524 }
4525 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4526 ecode2 = SWIG_AsVal_int(obj1, &val2);
4527 if (!SWIG_IsOK(ecode2)) {
4528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4529 }
4530 arg2 = static_cast< int >(val2);
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 (arg1)->SetPrecision(arg2);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 resultobj = SWIG_Py_Void();
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4545 PyObject *obj;
4546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4547 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4548 return SWIG_Py_Void();
4549 }
4550
4551 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4552 return SWIG_Python_InitShadowInstance(args);
4553 }
4554
4555 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4556 PyObject *resultobj = 0;
4557 wxGridCellBoolRenderer *result = 0 ;
4558
4559 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4560 {
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4563 wxPyEndAllowThreads(__tstate);
4564 if (PyErr_Occurred()) SWIG_fail;
4565 }
4566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *obj;
4575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4576 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4577 return SWIG_Py_Void();
4578 }
4579
4580 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 return SWIG_Python_InitShadowInstance(args);
4582 }
4583
4584 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4585 PyObject *resultobj = 0;
4586 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4587 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4588 wxGridCellDateTimeRenderer *result = 0 ;
4589 PyObject * obj0 = 0 ;
4590 PyObject * obj1 = 0 ;
4591 char * kwnames[] = {
4592 (char *) "outformat",(char *) "informat", NULL
4593 };
4594
4595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4596 if (obj0) {
4597 {
4598 wxString* sptr = wxString_in_helper(obj0);
4599 if (sptr == NULL) SWIG_fail;
4600 arg1 = *sptr;
4601 delete sptr;
4602 }
4603 }
4604 if (obj1) {
4605 {
4606 wxString* sptr = wxString_in_helper(obj1);
4607 if (sptr == NULL) SWIG_fail;
4608 arg2 = *sptr;
4609 delete sptr;
4610 }
4611 }
4612 {
4613 PyThreadState* __tstate = wxPyBeginAllowThreads();
4614 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4615 wxPyEndAllowThreads(__tstate);
4616 if (PyErr_Occurred()) SWIG_fail;
4617 }
4618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4619 return resultobj;
4620 fail:
4621 return NULL;
4622 }
4623
4624
4625 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4626 PyObject *obj;
4627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4628 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4629 return SWIG_Py_Void();
4630 }
4631
4632 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4633 return SWIG_Python_InitShadowInstance(args);
4634 }
4635
4636 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4637 PyObject *resultobj = 0;
4638 wxString const &arg1_defvalue = wxPyEmptyString ;
4639 wxString *arg1 = (wxString *) &arg1_defvalue ;
4640 wxGridCellEnumRenderer *result = 0 ;
4641 bool temp1 = false ;
4642 PyObject * obj0 = 0 ;
4643 char * kwnames[] = {
4644 (char *) "choices", NULL
4645 };
4646
4647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4648 if (obj0) {
4649 {
4650 arg1 = wxString_in_helper(obj0);
4651 if (arg1 == NULL) SWIG_fail;
4652 temp1 = true;
4653 }
4654 }
4655 {
4656 PyThreadState* __tstate = wxPyBeginAllowThreads();
4657 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4662 {
4663 if (temp1)
4664 delete arg1;
4665 }
4666 return resultobj;
4667 fail:
4668 {
4669 if (temp1)
4670 delete arg1;
4671 }
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4677 PyObject *obj;
4678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4679 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4680 return SWIG_Py_Void();
4681 }
4682
4683 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4684 return SWIG_Python_InitShadowInstance(args);
4685 }
4686
4687 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4688 PyObject *resultobj = 0;
4689 wxGridCellAutoWrapStringRenderer *result = 0 ;
4690
4691 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4695 wxPyEndAllowThreads(__tstate);
4696 if (PyErr_Occurred()) SWIG_fail;
4697 }
4698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4706 PyObject *obj;
4707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4708 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4709 return SWIG_Py_Void();
4710 }
4711
4712 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 return SWIG_Python_InitShadowInstance(args);
4714 }
4715
4716 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 PyObject *resultobj = 0;
4718 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4719 bool result;
4720 void *argp1 = 0 ;
4721 int res1 = 0 ;
4722 PyObject *swig_obj[1] ;
4723
4724 if (!args) SWIG_fail;
4725 swig_obj[0] = args;
4726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4727 if (!SWIG_IsOK(res1)) {
4728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4729 }
4730 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4731 {
4732 PyThreadState* __tstate = wxPyBeginAllowThreads();
4733 result = (bool)(arg1)->IsCreated();
4734 wxPyEndAllowThreads(__tstate);
4735 if (PyErr_Occurred()) SWIG_fail;
4736 }
4737 {
4738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4739 }
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4747 PyObject *resultobj = 0;
4748 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4749 wxControl *result = 0 ;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 PyObject *swig_obj[1] ;
4753
4754 if (!args) SWIG_fail;
4755 swig_obj[0] = args;
4756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4759 }
4760 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 result = (wxControl *)(arg1)->GetControl();
4764 wxPyEndAllowThreads(__tstate);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 {
4768 resultobj = wxPyMake_wxObject(result, 0);
4769 }
4770 return resultobj;
4771 fail:
4772 return NULL;
4773 }
4774
4775
4776 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj = 0;
4778 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4779 wxControl *arg2 = (wxControl *) 0 ;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 void *argp2 = 0 ;
4783 int res2 = 0 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 char * kwnames[] = {
4787 (char *) "self",(char *) "control", NULL
4788 };
4789
4790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4792 if (!SWIG_IsOK(res1)) {
4793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4794 }
4795 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4797 if (!SWIG_IsOK(res2)) {
4798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4799 }
4800 arg2 = reinterpret_cast< wxControl * >(argp2);
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->SetControl(arg2);
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_Py_Void();
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4815 PyObject *resultobj = 0;
4816 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4817 wxGridCellAttr *result = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 PyObject *swig_obj[1] ;
4821
4822 if (!args) SWIG_fail;
4823 swig_obj[0] = args;
4824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4827 }
4828 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4837 }
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj = 0;
4846 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4847 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4848 void *argp1 = 0 ;
4849 int res1 = 0 ;
4850 void *argp2 = 0 ;
4851 int res2 = 0 ;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 char * kwnames[] = {
4855 (char *) "self",(char *) "attr", NULL
4856 };
4857
4858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4860 if (!SWIG_IsOK(res1)) {
4861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4862 }
4863 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4865 if (!SWIG_IsOK(res2)) {
4866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4867 }
4868 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 (arg1)->SetCellAttr(arg2);
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4885 wxWindow *arg2 = (wxWindow *) 0 ;
4886 int arg3 ;
4887 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4888 void *argp1 = 0 ;
4889 int res1 = 0 ;
4890 void *argp2 = 0 ;
4891 int res2 = 0 ;
4892 int val3 ;
4893 int ecode3 = 0 ;
4894 void *argp4 = 0 ;
4895 int res4 = 0 ;
4896 PyObject * obj0 = 0 ;
4897 PyObject * obj1 = 0 ;
4898 PyObject * obj2 = 0 ;
4899 PyObject * obj3 = 0 ;
4900 char * kwnames[] = {
4901 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4902 };
4903
4904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4906 if (!SWIG_IsOK(res1)) {
4907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4908 }
4909 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4911 if (!SWIG_IsOK(res2)) {
4912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4913 }
4914 arg2 = reinterpret_cast< wxWindow * >(argp2);
4915 ecode3 = SWIG_AsVal_int(obj2, &val3);
4916 if (!SWIG_IsOK(ecode3)) {
4917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4918 }
4919 arg3 = static_cast< int >(val3);
4920 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4921 if (!SWIG_IsOK(res4)) {
4922 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4923 }
4924 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 (arg1)->Create(arg2,arg3,arg4);
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 resultobj = SWIG_Py_Void();
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj = 0;
4940 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4941 int arg2 ;
4942 int arg3 ;
4943 wxGrid *arg4 = (wxGrid *) 0 ;
4944 void *argp1 = 0 ;
4945 int res1 = 0 ;
4946 int val2 ;
4947 int ecode2 = 0 ;
4948 int val3 ;
4949 int ecode3 = 0 ;
4950 void *argp4 = 0 ;
4951 int res4 = 0 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 PyObject * obj2 = 0 ;
4955 PyObject * obj3 = 0 ;
4956 char * kwnames[] = {
4957 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4958 };
4959
4960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4962 if (!SWIG_IsOK(res1)) {
4963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4964 }
4965 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4966 ecode2 = SWIG_AsVal_int(obj1, &val2);
4967 if (!SWIG_IsOK(ecode2)) {
4968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4969 }
4970 arg2 = static_cast< int >(val2);
4971 ecode3 = SWIG_AsVal_int(obj2, &val3);
4972 if (!SWIG_IsOK(ecode3)) {
4973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4974 }
4975 arg3 = static_cast< int >(val3);
4976 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4977 if (!SWIG_IsOK(res4)) {
4978 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4979 }
4980 arg4 = reinterpret_cast< wxGrid * >(argp4);
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 (arg1)->BeginEdit(arg2,arg3,arg4);
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 resultobj = SWIG_Py_Void();
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj = 0;
4996 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4997 int arg2 ;
4998 int arg3 ;
4999 wxGrid *arg4 = (wxGrid *) 0 ;
5000 bool result;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 int val2 ;
5004 int ecode2 = 0 ;
5005 int val3 ;
5006 int ecode3 = 0 ;
5007 void *argp4 = 0 ;
5008 int res4 = 0 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 PyObject * obj2 = 0 ;
5012 PyObject * obj3 = 0 ;
5013 char * kwnames[] = {
5014 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5015 };
5016
5017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5019 if (!SWIG_IsOK(res1)) {
5020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5021 }
5022 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5023 ecode2 = SWIG_AsVal_int(obj1, &val2);
5024 if (!SWIG_IsOK(ecode2)) {
5025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5026 }
5027 arg2 = static_cast< int >(val2);
5028 ecode3 = SWIG_AsVal_int(obj2, &val3);
5029 if (!SWIG_IsOK(ecode3)) {
5030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5031 }
5032 arg3 = static_cast< int >(val3);
5033 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5034 if (!SWIG_IsOK(res4)) {
5035 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5036 }
5037 arg4 = reinterpret_cast< wxGrid * >(argp4);
5038 {
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 {
5045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5046 }
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054 PyObject *resultobj = 0;
5055 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5056 void *argp1 = 0 ;
5057 int res1 = 0 ;
5058 PyObject *swig_obj[1] ;
5059
5060 if (!args) SWIG_fail;
5061 swig_obj[0] = args;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5065 }
5066 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 (arg1)->Reset();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5083 wxGridCellEditor *result = 0 ;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5093 }
5094 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5113 wxRect *arg2 = 0 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 wxRect temp2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "self",(char *) "rect", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5127 }
5128 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5129 {
5130 arg2 = &temp2;
5131 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 (arg1)->SetSize((wxRect const &)*arg2);
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj = 0;
5148 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5149 bool arg2 ;
5150 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5151 void *argp1 = 0 ;
5152 int res1 = 0 ;
5153 bool val2 ;
5154 int ecode2 = 0 ;
5155 void *argp3 = 0 ;
5156 int res3 = 0 ;
5157 PyObject * obj0 = 0 ;
5158 PyObject * obj1 = 0 ;
5159 PyObject * obj2 = 0 ;
5160 char * kwnames[] = {
5161 (char *) "self",(char *) "show",(char *) "attr", NULL
5162 };
5163
5164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5166 if (!SWIG_IsOK(res1)) {
5167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5168 }
5169 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5171 if (!SWIG_IsOK(ecode2)) {
5172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5173 }
5174 arg2 = static_cast< bool >(val2);
5175 if (obj2) {
5176 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5177 if (!SWIG_IsOK(res3)) {
5178 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5179 }
5180 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5181 }
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->Show(arg2,arg3);
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj = 0;
5197 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5198 wxRect *arg2 = 0 ;
5199 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5200 void *argp1 = 0 ;
5201 int res1 = 0 ;
5202 wxRect temp2 ;
5203 void *argp3 = 0 ;
5204 int res3 = 0 ;
5205 PyObject * obj0 = 0 ;
5206 PyObject * obj1 = 0 ;
5207 PyObject * obj2 = 0 ;
5208 char * kwnames[] = {
5209 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5210 };
5211
5212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5214 if (!SWIG_IsOK(res1)) {
5215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5216 }
5217 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5218 {
5219 arg2 = &temp2;
5220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5221 }
5222 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5223 if (!SWIG_IsOK(res3)) {
5224 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5225 }
5226 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5230 wxPyEndAllowThreads(__tstate);
5231 if (PyErr_Occurred()) SWIG_fail;
5232 }
5233 resultobj = SWIG_Py_Void();
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj = 0;
5242 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5243 wxKeyEvent *arg2 = 0 ;
5244 bool result;
5245 void *argp1 = 0 ;
5246 int res1 = 0 ;
5247 void *argp2 = 0 ;
5248 int res2 = 0 ;
5249 PyObject * obj0 = 0 ;
5250 PyObject * obj1 = 0 ;
5251 char * kwnames[] = {
5252 (char *) "self",(char *) "event", NULL
5253 };
5254
5255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5257 if (!SWIG_IsOK(res1)) {
5258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5259 }
5260 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5262 if (!SWIG_IsOK(res2)) {
5263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5264 }
5265 if (!argp2) {
5266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5267 }
5268 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 {
5276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5277 }
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj = 0;
5286 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5287 wxKeyEvent *arg2 = 0 ;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 void *argp2 = 0 ;
5291 int res2 = 0 ;
5292 PyObject * obj0 = 0 ;
5293 PyObject * obj1 = 0 ;
5294 char * kwnames[] = {
5295 (char *) "self",(char *) "event", NULL
5296 };
5297
5298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5300 if (!SWIG_IsOK(res1)) {
5301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5302 }
5303 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5305 if (!SWIG_IsOK(res2)) {
5306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5307 }
5308 if (!argp2) {
5309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5310 }
5311 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5312 {
5313 PyThreadState* __tstate = wxPyBeginAllowThreads();
5314 (arg1)->StartingKey(*arg2);
5315 wxPyEndAllowThreads(__tstate);
5316 if (PyErr_Occurred()) SWIG_fail;
5317 }
5318 resultobj = SWIG_Py_Void();
5319 return resultobj;
5320 fail:
5321 return NULL;
5322 }
5323
5324
5325 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5326 PyObject *resultobj = 0;
5327 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5328 void *argp1 = 0 ;
5329 int res1 = 0 ;
5330 PyObject *swig_obj[1] ;
5331
5332 if (!args) SWIG_fail;
5333 swig_obj[0] = args;
5334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5335 if (!SWIG_IsOK(res1)) {
5336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5337 }
5338 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5339 {
5340 PyThreadState* __tstate = wxPyBeginAllowThreads();
5341 (arg1)->StartingClick();
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 resultobj = SWIG_Py_Void();
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj = 0;
5354 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5355 wxKeyEvent *arg2 = 0 ;
5356 void *argp1 = 0 ;
5357 int res1 = 0 ;
5358 void *argp2 = 0 ;
5359 int res2 = 0 ;
5360 PyObject * obj0 = 0 ;
5361 PyObject * obj1 = 0 ;
5362 char * kwnames[] = {
5363 (char *) "self",(char *) "event", NULL
5364 };
5365
5366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5368 if (!SWIG_IsOK(res1)) {
5369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5370 }
5371 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5373 if (!SWIG_IsOK(res2)) {
5374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5375 }
5376 if (!argp2) {
5377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5378 }
5379 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 (arg1)->HandleReturn(*arg2);
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 resultobj = SWIG_Py_Void();
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5394 PyObject *resultobj = 0;
5395 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5396 void *argp1 = 0 ;
5397 int res1 = 0 ;
5398 PyObject *swig_obj[1] ;
5399
5400 if (!args) SWIG_fail;
5401 swig_obj[0] = args;
5402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5403 if (!SWIG_IsOK(res1)) {
5404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5405 }
5406 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5407 {
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 (arg1)->Destroy();
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 resultobj = SWIG_Py_Void();
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5421 PyObject *obj;
5422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5423 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5424 return SWIG_Py_Void();
5425 }
5426
5427 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5428 PyObject *resultobj = 0;
5429 wxPyGridCellEditor *result = 0 ;
5430
5431 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj = 0;
5447 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5448 PyObject *arg2 = (PyObject *) 0 ;
5449 PyObject *arg3 = (PyObject *) 0 ;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 PyObject * obj2 = 0 ;
5455 char * kwnames[] = {
5456 (char *) "self",(char *) "self",(char *) "_class", NULL
5457 };
5458
5459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5461 if (!SWIG_IsOK(res1)) {
5462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5463 }
5464 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5465 arg2 = obj1;
5466 arg3 = obj2;
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 (arg1)->_setCallbackInfo(arg2,arg3);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_Py_Void();
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5483 wxString *arg2 = 0 ;
5484 void *argp1 = 0 ;
5485 int res1 = 0 ;
5486 bool temp2 = false ;
5487 PyObject * obj0 = 0 ;
5488 PyObject * obj1 = 0 ;
5489 char * kwnames[] = {
5490 (char *) "self",(char *) "params", NULL
5491 };
5492
5493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5495 if (!SWIG_IsOK(res1)) {
5496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5497 }
5498 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5499 {
5500 arg2 = wxString_in_helper(obj1);
5501 if (arg2 == NULL) SWIG_fail;
5502 temp2 = true;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 (arg1)->SetParameters((wxString const &)*arg2);
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_Py_Void();
5511 {
5512 if (temp2)
5513 delete arg2;
5514 }
5515 return resultobj;
5516 fail:
5517 {
5518 if (temp2)
5519 delete arg2;
5520 }
5521 return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *obj;
5527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5528 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5529 return SWIG_Py_Void();
5530 }
5531
5532 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 return SWIG_Python_InitShadowInstance(args);
5534 }
5535
5536 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537 PyObject *resultobj = 0;
5538 wxGridCellTextEditor *result = 0 ;
5539
5540 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5541 {
5542 PyThreadState* __tstate = wxPyBeginAllowThreads();
5543 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5555 PyObject *resultobj = 0;
5556 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5557 wxString result;
5558 void *argp1 = 0 ;
5559 int res1 = 0 ;
5560 PyObject *swig_obj[1] ;
5561
5562 if (!args) SWIG_fail;
5563 swig_obj[0] = args;
5564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5565 if (!SWIG_IsOK(res1)) {
5566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5567 }
5568 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5569 {
5570 PyThreadState* __tstate = wxPyBeginAllowThreads();
5571 result = (arg1)->GetValue();
5572 wxPyEndAllowThreads(__tstate);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 {
5576 #if wxUSE_UNICODE
5577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5578 #else
5579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5580 #endif
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *obj;
5590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5591 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5592 return SWIG_Py_Void();
5593 }
5594
5595 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5596 return SWIG_Python_InitShadowInstance(args);
5597 }
5598
5599 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj = 0;
5601 int arg1 = (int) -1 ;
5602 int arg2 = (int) -1 ;
5603 wxGridCellNumberEditor *result = 0 ;
5604 int val1 ;
5605 int ecode1 = 0 ;
5606 int val2 ;
5607 int ecode2 = 0 ;
5608 PyObject * obj0 = 0 ;
5609 PyObject * obj1 = 0 ;
5610 char * kwnames[] = {
5611 (char *) "min",(char *) "max", NULL
5612 };
5613
5614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5615 if (obj0) {
5616 ecode1 = SWIG_AsVal_int(obj0, &val1);
5617 if (!SWIG_IsOK(ecode1)) {
5618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5619 }
5620 arg1 = static_cast< int >(val1);
5621 }
5622 if (obj1) {
5623 ecode2 = SWIG_AsVal_int(obj1, &val2);
5624 if (!SWIG_IsOK(ecode2)) {
5625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5626 }
5627 arg2 = static_cast< int >(val2);
5628 }
5629 {
5630 PyThreadState* __tstate = wxPyBeginAllowThreads();
5631 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5643 PyObject *obj;
5644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5645 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5646 return SWIG_Py_Void();
5647 }
5648
5649 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5650 return SWIG_Python_InitShadowInstance(args);
5651 }
5652
5653 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5654 PyObject *resultobj = 0;
5655 int arg1 = (int) -1 ;
5656 int arg2 = (int) -1 ;
5657 wxGridCellFloatEditor *result = 0 ;
5658 int val1 ;
5659 int ecode1 = 0 ;
5660 int val2 ;
5661 int ecode2 = 0 ;
5662 PyObject * obj0 = 0 ;
5663 PyObject * obj1 = 0 ;
5664 char * kwnames[] = {
5665 (char *) "width",(char *) "precision", NULL
5666 };
5667
5668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5669 if (obj0) {
5670 ecode1 = SWIG_AsVal_int(obj0, &val1);
5671 if (!SWIG_IsOK(ecode1)) {
5672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5673 }
5674 arg1 = static_cast< int >(val1);
5675 }
5676 if (obj1) {
5677 ecode2 = SWIG_AsVal_int(obj1, &val2);
5678 if (!SWIG_IsOK(ecode2)) {
5679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5680 }
5681 arg2 = static_cast< int >(val2);
5682 }
5683 {
5684 PyThreadState* __tstate = wxPyBeginAllowThreads();
5685 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5686 wxPyEndAllowThreads(__tstate);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5690 return resultobj;
5691 fail:
5692 return NULL;
5693 }
5694
5695
5696 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697 PyObject *obj;
5698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5699 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5700 return SWIG_Py_Void();
5701 }
5702
5703 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 return SWIG_Python_InitShadowInstance(args);
5705 }
5706
5707 SWIGINTERN int OneString_set(PyObject *) {
5708 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5709 return 1;
5710 }
5711
5712
5713 SWIGINTERN PyObject *OneString_get(void) {
5714 PyObject *pyobj = 0;
5715
5716 {
5717 #if wxUSE_UNICODE
5718 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5719 #else
5720 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5721 #endif
5722 }
5723 return pyobj;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5728 PyObject *resultobj = 0;
5729 wxGridCellBoolEditor *result = 0 ;
5730
5731 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5732 {
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj = 0;
5747 wxString const &arg1_defvalue = wxPyOneString ;
5748 wxString *arg1 = (wxString *) &arg1_defvalue ;
5749 wxString const &arg2_defvalue = wxPyEmptyString ;
5750 wxString *arg2 = (wxString *) &arg2_defvalue ;
5751 bool temp1 = false ;
5752 bool temp2 = false ;
5753 PyObject * obj0 = 0 ;
5754 PyObject * obj1 = 0 ;
5755 char * kwnames[] = {
5756 (char *) "valueTrue",(char *) "valueFalse", NULL
5757 };
5758
5759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5760 if (obj0) {
5761 {
5762 arg1 = wxString_in_helper(obj0);
5763 if (arg1 == NULL) SWIG_fail;
5764 temp1 = true;
5765 }
5766 }
5767 if (obj1) {
5768 {
5769 arg2 = wxString_in_helper(obj1);
5770 if (arg2 == NULL) SWIG_fail;
5771 temp2 = true;
5772 }
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5777 wxPyEndAllowThreads(__tstate);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 resultobj = SWIG_Py_Void();
5781 {
5782 if (temp1)
5783 delete arg1;
5784 }
5785 {
5786 if (temp2)
5787 delete arg2;
5788 }
5789 return resultobj;
5790 fail:
5791 {
5792 if (temp1)
5793 delete arg1;
5794 }
5795 {
5796 if (temp2)
5797 delete arg2;
5798 }
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj = 0;
5805 wxString *arg1 = 0 ;
5806 bool result;
5807 bool temp1 = false ;
5808 PyObject * obj0 = 0 ;
5809 char * kwnames[] = {
5810 (char *) "value", NULL
5811 };
5812
5813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5814 {
5815 arg1 = wxString_in_helper(obj0);
5816 if (arg1 == NULL) SWIG_fail;
5817 temp1 = true;
5818 }
5819 {
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 {
5826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5827 }
5828 {
5829 if (temp1)
5830 delete arg1;
5831 }
5832 return resultobj;
5833 fail:
5834 {
5835 if (temp1)
5836 delete arg1;
5837 }
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5843 PyObject *obj;
5844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5845 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5846 return SWIG_Py_Void();
5847 }
5848
5849 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5850 return SWIG_Python_InitShadowInstance(args);
5851 }
5852
5853 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj = 0;
5855 int arg1 = (int) 0 ;
5856 wxString *arg2 = (wxString *) NULL ;
5857 bool arg3 = (bool) false ;
5858 wxGridCellChoiceEditor *result = 0 ;
5859 bool val3 ;
5860 int ecode3 = 0 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char * kwnames[] = {
5864 (char *) "choices",(char *) "allowOthers", NULL
5865 };
5866
5867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5868 if (obj0) {
5869 {
5870 arg1 = PyList_Size(obj0);
5871 arg2 = wxString_LIST_helper(obj0);
5872 if (arg2 == NULL) SWIG_fail;
5873 }
5874 }
5875 if (obj1) {
5876 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5877 if (!SWIG_IsOK(ecode3)) {
5878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5879 }
5880 arg3 = static_cast< bool >(val3);
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5885 wxPyEndAllowThreads(__tstate);
5886 if (PyErr_Occurred()) SWIG_fail;
5887 }
5888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5889 {
5890 if (arg2) delete [] arg2;
5891 }
5892 return resultobj;
5893 fail:
5894 {
5895 if (arg2) delete [] arg2;
5896 }
5897 return NULL;
5898 }
5899
5900
5901 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5902 PyObject *obj;
5903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5904 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5905 return SWIG_Py_Void();
5906 }
5907
5908 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5909 return SWIG_Python_InitShadowInstance(args);
5910 }
5911
5912 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5913 PyObject *resultobj = 0;
5914 wxString const &arg1_defvalue = wxPyEmptyString ;
5915 wxString *arg1 = (wxString *) &arg1_defvalue ;
5916 wxGridCellEnumEditor *result = 0 ;
5917 bool temp1 = false ;
5918 PyObject * obj0 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "choices", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5924 if (obj0) {
5925 {
5926 arg1 = wxString_in_helper(obj0);
5927 if (arg1 == NULL) SWIG_fail;
5928 temp1 = true;
5929 }
5930 }
5931 {
5932 PyThreadState* __tstate = wxPyBeginAllowThreads();
5933 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5938 {
5939 if (temp1)
5940 delete arg1;
5941 }
5942 return resultobj;
5943 fail:
5944 {
5945 if (temp1)
5946 delete arg1;
5947 }
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5953 PyObject *obj;
5954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5955 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5956 return SWIG_Py_Void();
5957 }
5958
5959 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5960 return SWIG_Python_InitShadowInstance(args);
5961 }
5962
5963 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5964 PyObject *resultobj = 0;
5965 wxGridCellAutoWrapStringEditor *result = 0 ;
5966
5967 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5982 PyObject *obj;
5983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5984 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5985 return SWIG_Py_Void();
5986 }
5987
5988 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5989 return SWIG_Python_InitShadowInstance(args);
5990 }
5991
5992 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj = 0;
5994 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5995 PyObject *arg2 = (PyObject *) 0 ;
5996 void *argp1 = 0 ;
5997 int res1 = 0 ;
5998 PyObject * obj0 = 0 ;
5999 PyObject * obj1 = 0 ;
6000 char * kwnames[] = {
6001 (char *) "self",(char *) "_self", NULL
6002 };
6003
6004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6006 if (!SWIG_IsOK(res1)) {
6007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6008 }
6009 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6010 arg2 = obj1;
6011 {
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 wxGridCellAttr__setOORInfo(arg1,arg2);
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 resultobj = SWIG_Py_Void();
6018 return resultobj;
6019 fail:
6020 return NULL;
6021 }
6022
6023
6024 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6025 PyObject *resultobj = 0;
6026 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6027 wxGridCellAttr *result = 0 ;
6028 void *argp1 = 0 ;
6029 int res1 = 0 ;
6030 PyObject * obj0 = 0 ;
6031 char * kwnames[] = {
6032 (char *) "attrDefault", NULL
6033 };
6034
6035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6036 if (obj0) {
6037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6038 if (!SWIG_IsOK(res1)) {
6039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6040 }
6041 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6042 }
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 {
6050 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6051 }
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6059 PyObject *resultobj = 0;
6060 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6061 void *argp1 = 0 ;
6062 int res1 = 0 ;
6063 PyObject *swig_obj[1] ;
6064
6065 if (!args) SWIG_fail;
6066 swig_obj[0] = args;
6067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6068 if (!SWIG_IsOK(res1)) {
6069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6070 }
6071 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6072 {
6073 PyThreadState* __tstate = wxPyBeginAllowThreads();
6074 delete_wxGridCellAttr(arg1);
6075
6076 wxPyEndAllowThreads(__tstate);
6077 if (PyErr_Occurred()) SWIG_fail;
6078 }
6079 resultobj = SWIG_Py_Void();
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6087 PyObject *resultobj = 0;
6088 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6089 wxGridCellAttr *result = 0 ;
6090 void *argp1 = 0 ;
6091 int res1 = 0 ;
6092 PyObject *swig_obj[1] ;
6093
6094 if (!args) SWIG_fail;
6095 swig_obj[0] = args;
6096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6097 if (!SWIG_IsOK(res1)) {
6098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6099 }
6100 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj = 0;
6118 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6119 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6120 void *argp1 = 0 ;
6121 int res1 = 0 ;
6122 void *argp2 = 0 ;
6123 int res2 = 0 ;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 char * kwnames[] = {
6127 (char *) "self",(char *) "mergefrom", NULL
6128 };
6129
6130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6132 if (!SWIG_IsOK(res1)) {
6133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6134 }
6135 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6137 if (!SWIG_IsOK(res2)) {
6138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6139 }
6140 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 (arg1)->MergeWith(arg2);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_Py_Void();
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6157 void *argp1 = 0 ;
6158 int res1 = 0 ;
6159 PyObject *swig_obj[1] ;
6160
6161 if (!args) SWIG_fail;
6162 swig_obj[0] = args;
6163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6164 if (!SWIG_IsOK(res1)) {
6165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6166 }
6167 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6168 {
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 (arg1)->IncRef();
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 resultobj = SWIG_Py_Void();
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6182 PyObject *resultobj = 0;
6183 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6184 void *argp1 = 0 ;
6185 int res1 = 0 ;
6186 PyObject *swig_obj[1] ;
6187
6188 if (!args) SWIG_fail;
6189 swig_obj[0] = args;
6190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6191 if (!SWIG_IsOK(res1)) {
6192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6193 }
6194 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6195 {
6196 PyThreadState* __tstate = wxPyBeginAllowThreads();
6197 (arg1)->DecRef();
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 resultobj = SWIG_Py_Void();
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj = 0;
6210 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6211 wxColour *arg2 = 0 ;
6212 void *argp1 = 0 ;
6213 int res1 = 0 ;
6214 wxColour temp2 ;
6215 PyObject * obj0 = 0 ;
6216 PyObject * obj1 = 0 ;
6217 char * kwnames[] = {
6218 (char *) "self",(char *) "colText", NULL
6219 };
6220
6221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6223 if (!SWIG_IsOK(res1)) {
6224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6225 }
6226 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6227 {
6228 arg2 = &temp2;
6229 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6230 }
6231 {
6232 PyThreadState* __tstate = wxPyBeginAllowThreads();
6233 (arg1)->SetTextColour((wxColour const &)*arg2);
6234 wxPyEndAllowThreads(__tstate);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 resultobj = SWIG_Py_Void();
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj = 0;
6246 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6247 wxColour *arg2 = 0 ;
6248 void *argp1 = 0 ;
6249 int res1 = 0 ;
6250 wxColour temp2 ;
6251 PyObject * obj0 = 0 ;
6252 PyObject * obj1 = 0 ;
6253 char * kwnames[] = {
6254 (char *) "self",(char *) "colBack", NULL
6255 };
6256
6257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6261 }
6262 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6263 {
6264 arg2 = &temp2;
6265 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6266 }
6267 {
6268 PyThreadState* __tstate = wxPyBeginAllowThreads();
6269 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 resultobj = SWIG_Py_Void();
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj = 0;
6282 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6283 wxFont *arg2 = 0 ;
6284 void *argp1 = 0 ;
6285 int res1 = 0 ;
6286 void *argp2 = 0 ;
6287 int res2 = 0 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 char * kwnames[] = {
6291 (char *) "self",(char *) "font", NULL
6292 };
6293
6294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6296 if (!SWIG_IsOK(res1)) {
6297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6298 }
6299 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6300 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6301 if (!SWIG_IsOK(res2)) {
6302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6303 }
6304 if (!argp2) {
6305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6306 }
6307 arg2 = reinterpret_cast< wxFont * >(argp2);
6308 {
6309 PyThreadState* __tstate = wxPyBeginAllowThreads();
6310 (arg1)->SetFont((wxFont const &)*arg2);
6311 wxPyEndAllowThreads(__tstate);
6312 if (PyErr_Occurred()) SWIG_fail;
6313 }
6314 resultobj = SWIG_Py_Void();
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj = 0;
6323 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6324 int arg2 ;
6325 int arg3 ;
6326 void *argp1 = 0 ;
6327 int res1 = 0 ;
6328 int val2 ;
6329 int ecode2 = 0 ;
6330 int val3 ;
6331 int ecode3 = 0 ;
6332 PyObject * obj0 = 0 ;
6333 PyObject * obj1 = 0 ;
6334 PyObject * obj2 = 0 ;
6335 char * kwnames[] = {
6336 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6337 };
6338
6339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6341 if (!SWIG_IsOK(res1)) {
6342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6343 }
6344 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6345 ecode2 = SWIG_AsVal_int(obj1, &val2);
6346 if (!SWIG_IsOK(ecode2)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6348 }
6349 arg2 = static_cast< int >(val2);
6350 ecode3 = SWIG_AsVal_int(obj2, &val3);
6351 if (!SWIG_IsOK(ecode3)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6353 }
6354 arg3 = static_cast< int >(val3);
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 (arg1)->SetAlignment(arg2,arg3);
6358 wxPyEndAllowThreads(__tstate);
6359 if (PyErr_Occurred()) SWIG_fail;
6360 }
6361 resultobj = SWIG_Py_Void();
6362 return resultobj;
6363 fail:
6364 return NULL;
6365 }
6366
6367
6368 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6369 PyObject *resultobj = 0;
6370 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6371 int arg2 ;
6372 int arg3 ;
6373 void *argp1 = 0 ;
6374 int res1 = 0 ;
6375 int val2 ;
6376 int ecode2 = 0 ;
6377 int val3 ;
6378 int ecode3 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 PyObject * obj2 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6390 }
6391 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 ecode3 = SWIG_AsVal_int(obj2, &val3);
6398 if (!SWIG_IsOK(ecode3)) {
6399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6400 }
6401 arg3 = static_cast< int >(val3);
6402 {
6403 PyThreadState* __tstate = wxPyBeginAllowThreads();
6404 (arg1)->SetSize(arg2,arg3);
6405 wxPyEndAllowThreads(__tstate);
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 resultobj = SWIG_Py_Void();
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj = 0;
6417 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6418 bool arg2 = (bool) true ;
6419 void *argp1 = 0 ;
6420 int res1 = 0 ;
6421 bool val2 ;
6422 int ecode2 = 0 ;
6423 PyObject * obj0 = 0 ;
6424 PyObject * obj1 = 0 ;
6425 char * kwnames[] = {
6426 (char *) "self",(char *) "allow", NULL
6427 };
6428
6429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6431 if (!SWIG_IsOK(res1)) {
6432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6433 }
6434 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6435 if (obj1) {
6436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6437 if (!SWIG_IsOK(ecode2)) {
6438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6439 }
6440 arg2 = static_cast< bool >(val2);
6441 }
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->SetOverflow(arg2);
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_Py_Void();
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj = 0;
6457 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6458 bool arg2 = (bool) true ;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 bool val2 ;
6462 int ecode2 = 0 ;
6463 PyObject * obj0 = 0 ;
6464 PyObject * obj1 = 0 ;
6465 char * kwnames[] = {
6466 (char *) "self",(char *) "isReadOnly", NULL
6467 };
6468
6469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6473 }
6474 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6475 if (obj1) {
6476 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6477 if (!SWIG_IsOK(ecode2)) {
6478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6479 }
6480 arg2 = static_cast< bool >(val2);
6481 }
6482 {
6483 PyThreadState* __tstate = wxPyBeginAllowThreads();
6484 (arg1)->SetReadOnly(arg2);
6485 wxPyEndAllowThreads(__tstate);
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 resultobj = SWIG_Py_Void();
6489 return resultobj;
6490 fail:
6491 return NULL;
6492 }
6493
6494
6495 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6496 PyObject *resultobj = 0;
6497 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6498 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6499 void *argp1 = 0 ;
6500 int res1 = 0 ;
6501 void *argp2 = 0 ;
6502 int res2 = 0 ;
6503 PyObject * obj0 = 0 ;
6504 PyObject * obj1 = 0 ;
6505 char * kwnames[] = {
6506 (char *) "self",(char *) "renderer", NULL
6507 };
6508
6509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6511 if (!SWIG_IsOK(res1)) {
6512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6513 }
6514 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6516 if (!SWIG_IsOK(res2)) {
6517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6518 }
6519 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 (arg1)->SetRenderer(arg2);
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_Py_Void();
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj = 0;
6535 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6536 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6537 void *argp1 = 0 ;
6538 int res1 = 0 ;
6539 void *argp2 = 0 ;
6540 int res2 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "editor", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6551 }
6552 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6554 if (!SWIG_IsOK(res2)) {
6555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6556 }
6557 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 (arg1)->SetEditor(arg2);
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_Py_Void();
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj = 0;
6573 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6574 wxGridCellAttr::wxAttrKind arg2 ;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 int val2 ;
6578 int ecode2 = 0 ;
6579 PyObject * obj0 = 0 ;
6580 PyObject * obj1 = 0 ;
6581 char * kwnames[] = {
6582 (char *) "self",(char *) "kind", NULL
6583 };
6584
6585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6587 if (!SWIG_IsOK(res1)) {
6588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6589 }
6590 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6591 ecode2 = SWIG_AsVal_int(obj1, &val2);
6592 if (!SWIG_IsOK(ecode2)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6594 }
6595 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6596 {
6597 PyThreadState* __tstate = wxPyBeginAllowThreads();
6598 (arg1)->SetKind(arg2);
6599 wxPyEndAllowThreads(__tstate);
6600 if (PyErr_Occurred()) SWIG_fail;
6601 }
6602 resultobj = SWIG_Py_Void();
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6610 PyObject *resultobj = 0;
6611 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6612 bool result;
6613 void *argp1 = 0 ;
6614 int res1 = 0 ;
6615 PyObject *swig_obj[1] ;
6616
6617 if (!args) SWIG_fail;
6618 swig_obj[0] = args;
6619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6620 if (!SWIG_IsOK(res1)) {
6621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6622 }
6623 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 {
6631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6632 }
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6640 PyObject *resultobj = 0;
6641 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6642 bool result;
6643 void *argp1 = 0 ;
6644 int res1 = 0 ;
6645 PyObject *swig_obj[1] ;
6646
6647 if (!args) SWIG_fail;
6648 swig_obj[0] = args;
6649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6650 if (!SWIG_IsOK(res1)) {
6651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6652 }
6653 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6654 {
6655 PyThreadState* __tstate = wxPyBeginAllowThreads();
6656 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6657 wxPyEndAllowThreads(__tstate);
6658 if (PyErr_Occurred()) SWIG_fail;
6659 }
6660 {
6661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6662 }
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6672 bool result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6702 bool result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 {
6721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6722 }
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6732 bool result;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 PyObject *swig_obj[1] ;
6736
6737 if (!args) SWIG_fail;
6738 swig_obj[0] = args;
6739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6740 if (!SWIG_IsOK(res1)) {
6741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6742 }
6743 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 {
6751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6752 }
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6760 PyObject *resultobj = 0;
6761 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6762 bool result;
6763 void *argp1 = 0 ;
6764 int res1 = 0 ;
6765 PyObject *swig_obj[1] ;
6766
6767 if (!args) SWIG_fail;
6768 swig_obj[0] = args;
6769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6770 if (!SWIG_IsOK(res1)) {
6771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6772 }
6773 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 {
6781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6782 }
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6790 PyObject *resultobj = 0;
6791 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6792 bool result;
6793 void *argp1 = 0 ;
6794 int res1 = 0 ;
6795 PyObject *swig_obj[1] ;
6796
6797 if (!args) SWIG_fail;
6798 swig_obj[0] = args;
6799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6800 if (!SWIG_IsOK(res1)) {
6801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6802 }
6803 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 {
6811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6812 }
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6822 bool result;
6823 void *argp1 = 0 ;
6824 int res1 = 0 ;
6825 PyObject *swig_obj[1] ;
6826
6827 if (!args) SWIG_fail;
6828 swig_obj[0] = args;
6829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6830 if (!SWIG_IsOK(res1)) {
6831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6832 }
6833 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6842 }
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6850 PyObject *resultobj = 0;
6851 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6852 wxColour result;
6853 void *argp1 = 0 ;
6854 int res1 = 0 ;
6855 PyObject *swig_obj[1] ;
6856
6857 if (!args) SWIG_fail;
6858 swig_obj[0] = args;
6859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6860 if (!SWIG_IsOK(res1)) {
6861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6862 }
6863 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6878 PyObject *resultobj = 0;
6879 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6880 wxColour result;
6881 void *argp1 = 0 ;
6882 int res1 = 0 ;
6883 PyObject *swig_obj[1] ;
6884
6885 if (!args) SWIG_fail;
6886 swig_obj[0] = args;
6887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6888 if (!SWIG_IsOK(res1)) {
6889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6890 }
6891 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6906 PyObject *resultobj = 0;
6907 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6908 wxFont result;
6909 void *argp1 = 0 ;
6910 int res1 = 0 ;
6911 PyObject *swig_obj[1] ;
6912
6913 if (!args) SWIG_fail;
6914 swig_obj[0] = args;
6915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6918 }
6919 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 result = ((wxGridCellAttr const *)arg1)->GetFont();
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6934 PyObject *resultobj = 0;
6935 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6936 int *arg2 = (int *) 0 ;
6937 int *arg3 = (int *) 0 ;
6938 void *argp1 = 0 ;
6939 int res1 = 0 ;
6940 int temp2 ;
6941 int res2 = SWIG_TMPOBJ ;
6942 int temp3 ;
6943 int res3 = SWIG_TMPOBJ ;
6944 PyObject *swig_obj[1] ;
6945
6946 arg2 = &temp2;
6947 arg3 = &temp3;
6948 if (!args) SWIG_fail;
6949 swig_obj[0] = args;
6950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6953 }
6954 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6955 {
6956 PyThreadState* __tstate = wxPyBeginAllowThreads();
6957 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6958 wxPyEndAllowThreads(__tstate);
6959 if (PyErr_Occurred()) SWIG_fail;
6960 }
6961 resultobj = SWIG_Py_Void();
6962 if (SWIG_IsTmpObj(res2)) {
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6964 } else {
6965 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6967 }
6968 if (SWIG_IsTmpObj(res3)) {
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6970 } else {
6971 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6973 }
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6981 PyObject *resultobj = 0;
6982 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6983 int *arg2 = (int *) 0 ;
6984 int *arg3 = (int *) 0 ;
6985 void *argp1 = 0 ;
6986 int res1 = 0 ;
6987 int temp2 ;
6988 int res2 = SWIG_TMPOBJ ;
6989 int temp3 ;
6990 int res3 = SWIG_TMPOBJ ;
6991 PyObject *swig_obj[1] ;
6992
6993 arg2 = &temp2;
6994 arg3 = &temp3;
6995 if (!args) SWIG_fail;
6996 swig_obj[0] = args;
6997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7000 }
7001 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 if (SWIG_IsTmpObj(res2)) {
7010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7011 } else {
7012 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7014 }
7015 if (SWIG_IsTmpObj(res3)) {
7016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7017 } else {
7018 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7028 PyObject *resultobj = 0;
7029 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7030 bool result;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 PyObject *swig_obj[1] ;
7034
7035 if (!args) SWIG_fail;
7036 swig_obj[0] = args;
7037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7038 if (!SWIG_IsOK(res1)) {
7039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7040 }
7041 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 {
7049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7050 }
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj = 0;
7059 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7060 wxGrid *arg2 = (wxGrid *) 0 ;
7061 int arg3 ;
7062 int arg4 ;
7063 wxGridCellRenderer *result = 0 ;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 void *argp2 = 0 ;
7067 int res2 = 0 ;
7068 int val3 ;
7069 int ecode3 = 0 ;
7070 int val4 ;
7071 int ecode4 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 PyObject * obj1 = 0 ;
7074 PyObject * obj2 = 0 ;
7075 PyObject * obj3 = 0 ;
7076 char * kwnames[] = {
7077 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7078 };
7079
7080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7082 if (!SWIG_IsOK(res1)) {
7083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7084 }
7085 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7087 if (!SWIG_IsOK(res2)) {
7088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7089 }
7090 arg2 = reinterpret_cast< wxGrid * >(argp2);
7091 ecode3 = SWIG_AsVal_int(obj2, &val3);
7092 if (!SWIG_IsOK(ecode3)) {
7093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7094 }
7095 arg3 = static_cast< int >(val3);
7096 ecode4 = SWIG_AsVal_int(obj3, &val4);
7097 if (!SWIG_IsOK(ecode4)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7099 }
7100 arg4 = static_cast< int >(val4);
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 {
7108 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7109 }
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7119 wxGrid *arg2 = (wxGrid *) 0 ;
7120 int arg3 ;
7121 int arg4 ;
7122 wxGridCellEditor *result = 0 ;
7123 void *argp1 = 0 ;
7124 int res1 = 0 ;
7125 void *argp2 = 0 ;
7126 int res2 = 0 ;
7127 int val3 ;
7128 int ecode3 = 0 ;
7129 int val4 ;
7130 int ecode4 = 0 ;
7131 PyObject * obj0 = 0 ;
7132 PyObject * obj1 = 0 ;
7133 PyObject * obj2 = 0 ;
7134 PyObject * obj3 = 0 ;
7135 char * kwnames[] = {
7136 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7137 };
7138
7139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7141 if (!SWIG_IsOK(res1)) {
7142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7143 }
7144 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7146 if (!SWIG_IsOK(res2)) {
7147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7148 }
7149 arg2 = reinterpret_cast< wxGrid * >(argp2);
7150 ecode3 = SWIG_AsVal_int(obj2, &val3);
7151 if (!SWIG_IsOK(ecode3)) {
7152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7153 }
7154 arg3 = static_cast< int >(val3);
7155 ecode4 = SWIG_AsVal_int(obj3, &val4);
7156 if (!SWIG_IsOK(ecode4)) {
7157 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7158 }
7159 arg4 = static_cast< int >(val4);
7160 {
7161 PyThreadState* __tstate = wxPyBeginAllowThreads();
7162 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 {
7167 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7168 }
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7176 PyObject *resultobj = 0;
7177 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7178 bool result;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 PyObject *swig_obj[1] ;
7182
7183 if (!args) SWIG_fail;
7184 swig_obj[0] = args;
7185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7186 if (!SWIG_IsOK(res1)) {
7187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7188 }
7189 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 {
7197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7198 }
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7206 PyObject *resultobj = 0;
7207 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7208 wxGridCellAttr::wxAttrKind result;
7209 void *argp1 = 0 ;
7210 int res1 = 0 ;
7211 PyObject *swig_obj[1] ;
7212
7213 if (!args) SWIG_fail;
7214 swig_obj[0] = args;
7215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7218 }
7219 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 resultobj = SWIG_From_int(static_cast< int >(result));
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj = 0;
7235 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7236 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7237 void *argp1 = 0 ;
7238 int res1 = 0 ;
7239 void *argp2 = 0 ;
7240 int res2 = 0 ;
7241 PyObject * obj0 = 0 ;
7242 PyObject * obj1 = 0 ;
7243 char * kwnames[] = {
7244 (char *) "self",(char *) "defAttr", NULL
7245 };
7246
7247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7251 }
7252 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7254 if (!SWIG_IsOK(res2)) {
7255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7256 }
7257 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7258 {
7259 PyThreadState* __tstate = wxPyBeginAllowThreads();
7260 (arg1)->SetDefAttr(arg2);
7261 wxPyEndAllowThreads(__tstate);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_Py_Void();
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7272 PyObject *obj;
7273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7274 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7275 return SWIG_Py_Void();
7276 }
7277
7278 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7279 return SWIG_Python_InitShadowInstance(args);
7280 }
7281
7282 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283 PyObject *resultobj = 0;
7284 wxGridCellAttrProvider *result = 0 ;
7285
7286 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 {
7294 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7295 }
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7303 PyObject *resultobj = 0;
7304 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7305 PyObject *arg2 = (PyObject *) 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 PyObject * obj0 = 0 ;
7309 PyObject * obj1 = 0 ;
7310 char * kwnames[] = {
7311 (char *) "self",(char *) "_self", NULL
7312 };
7313
7314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7316 if (!SWIG_IsOK(res1)) {
7317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7318 }
7319 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7320 arg2 = obj1;
7321 {
7322 PyThreadState* __tstate = wxPyBeginAllowThreads();
7323 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = SWIG_Py_Void();
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7335 PyObject *resultobj = 0;
7336 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7337 int arg2 ;
7338 int arg3 ;
7339 wxGridCellAttr::wxAttrKind arg4 ;
7340 wxGridCellAttr *result = 0 ;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 int val2 ;
7344 int ecode2 = 0 ;
7345 int val3 ;
7346 int ecode3 = 0 ;
7347 int val4 ;
7348 int ecode4 = 0 ;
7349 PyObject * obj0 = 0 ;
7350 PyObject * obj1 = 0 ;
7351 PyObject * obj2 = 0 ;
7352 PyObject * obj3 = 0 ;
7353 char * kwnames[] = {
7354 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7355 };
7356
7357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7359 if (!SWIG_IsOK(res1)) {
7360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7361 }
7362 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7363 ecode2 = SWIG_AsVal_int(obj1, &val2);
7364 if (!SWIG_IsOK(ecode2)) {
7365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7366 }
7367 arg2 = static_cast< int >(val2);
7368 ecode3 = SWIG_AsVal_int(obj2, &val3);
7369 if (!SWIG_IsOK(ecode3)) {
7370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7371 }
7372 arg3 = static_cast< int >(val3);
7373 ecode4 = SWIG_AsVal_int(obj3, &val4);
7374 if (!SWIG_IsOK(ecode4)) {
7375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7376 }
7377 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7378 {
7379 PyThreadState* __tstate = wxPyBeginAllowThreads();
7380 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7381 wxPyEndAllowThreads(__tstate);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 {
7385 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7386 }
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7396 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7397 int arg3 ;
7398 int arg4 ;
7399 void *argp1 = 0 ;
7400 int res1 = 0 ;
7401 void *argp2 = 0 ;
7402 int res2 = 0 ;
7403 int val3 ;
7404 int ecode3 = 0 ;
7405 int val4 ;
7406 int ecode4 = 0 ;
7407 PyObject * obj0 = 0 ;
7408 PyObject * obj1 = 0 ;
7409 PyObject * obj2 = 0 ;
7410 PyObject * obj3 = 0 ;
7411 char * kwnames[] = {
7412 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7413 };
7414
7415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7419 }
7420 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7422 if (!SWIG_IsOK(res2)) {
7423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7424 }
7425 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7426 ecode3 = SWIG_AsVal_int(obj2, &val3);
7427 if (!SWIG_IsOK(ecode3)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7429 }
7430 arg3 = static_cast< int >(val3);
7431 ecode4 = SWIG_AsVal_int(obj3, &val4);
7432 if (!SWIG_IsOK(ecode4)) {
7433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7434 }
7435 arg4 = static_cast< int >(val4);
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->SetAttr(arg2,arg3,arg4);
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7452 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7453 int arg3 ;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 void *argp2 = 0 ;
7457 int res2 = 0 ;
7458 int val3 ;
7459 int ecode3 = 0 ;
7460 PyObject * obj0 = 0 ;
7461 PyObject * obj1 = 0 ;
7462 PyObject * obj2 = 0 ;
7463 char * kwnames[] = {
7464 (char *) "self",(char *) "attr",(char *) "row", NULL
7465 };
7466
7467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7469 if (!SWIG_IsOK(res1)) {
7470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7471 }
7472 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7474 if (!SWIG_IsOK(res2)) {
7475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7476 }
7477 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7478 ecode3 = SWIG_AsVal_int(obj2, &val3);
7479 if (!SWIG_IsOK(ecode3)) {
7480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7481 }
7482 arg3 = static_cast< int >(val3);
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 (arg1)->SetRowAttr(arg2,arg3);
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 resultobj = SWIG_Py_Void();
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj = 0;
7498 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7499 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7500 int arg3 ;
7501 void *argp1 = 0 ;
7502 int res1 = 0 ;
7503 void *argp2 = 0 ;
7504 int res2 = 0 ;
7505 int val3 ;
7506 int ecode3 = 0 ;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 PyObject * obj2 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "attr",(char *) "col", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7518 }
7519 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7521 if (!SWIG_IsOK(res2)) {
7522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7523 }
7524 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7525 ecode3 = SWIG_AsVal_int(obj2, &val3);
7526 if (!SWIG_IsOK(ecode3)) {
7527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7528 }
7529 arg3 = static_cast< int >(val3);
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 (arg1)->SetColAttr(arg2,arg3);
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7546 size_t arg2 ;
7547 int arg3 ;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 size_t val2 ;
7551 int ecode2 = 0 ;
7552 int val3 ;
7553 int ecode3 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 PyObject * obj2 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7565 }
7566 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7567 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7568 if (!SWIG_IsOK(ecode2)) {
7569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7570 }
7571 arg2 = static_cast< size_t >(val2);
7572 ecode3 = SWIG_AsVal_int(obj2, &val3);
7573 if (!SWIG_IsOK(ecode3)) {
7574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7575 }
7576 arg3 = static_cast< int >(val3);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 (arg1)->UpdateAttrRows(arg2,arg3);
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 resultobj = SWIG_Py_Void();
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj = 0;
7592 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7593 size_t arg2 ;
7594 int arg3 ;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 size_t val2 ;
7598 int ecode2 = 0 ;
7599 int val3 ;
7600 int ecode3 = 0 ;
7601 PyObject * obj0 = 0 ;
7602 PyObject * obj1 = 0 ;
7603 PyObject * obj2 = 0 ;
7604 char * kwnames[] = {
7605 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7606 };
7607
7608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7610 if (!SWIG_IsOK(res1)) {
7611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7612 }
7613 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7614 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7615 if (!SWIG_IsOK(ecode2)) {
7616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7617 }
7618 arg2 = static_cast< size_t >(val2);
7619 ecode3 = SWIG_AsVal_int(obj2, &val3);
7620 if (!SWIG_IsOK(ecode3)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7622 }
7623 arg3 = static_cast< int >(val3);
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->UpdateAttrCols(arg2,arg3);
7627 wxPyEndAllowThreads(__tstate);
7628 if (PyErr_Occurred()) SWIG_fail;
7629 }
7630 resultobj = SWIG_Py_Void();
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7638 PyObject *obj;
7639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7640 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7641 return SWIG_Py_Void();
7642 }
7643
7644 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 return SWIG_Python_InitShadowInstance(args);
7646 }
7647
7648 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7649 PyObject *resultobj = 0;
7650 wxPyGridCellAttrProvider *result = 0 ;
7651
7652 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7653 {
7654 PyThreadState* __tstate = wxPyBeginAllowThreads();
7655 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj = 0;
7668 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7669 PyObject *arg2 = (PyObject *) 0 ;
7670 PyObject *arg3 = (PyObject *) 0 ;
7671 void *argp1 = 0 ;
7672 int res1 = 0 ;
7673 PyObject * obj0 = 0 ;
7674 PyObject * obj1 = 0 ;
7675 PyObject * obj2 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "self",(char *) "_class", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7684 }
7685 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7686 arg2 = obj1;
7687 arg3 = obj2;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 (arg1)->_setCallbackInfo(arg2,arg3);
7691 wxPyEndAllowThreads(__tstate);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 resultobj = SWIG_Py_Void();
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7702 PyObject *resultobj = 0;
7703 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7704 int arg2 ;
7705 int arg3 ;
7706 wxGridCellAttr::wxAttrKind arg4 ;
7707 wxGridCellAttr *result = 0 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 int val3 ;
7713 int ecode3 = 0 ;
7714 int val4 ;
7715 int ecode4 = 0 ;
7716 PyObject * obj0 = 0 ;
7717 PyObject * obj1 = 0 ;
7718 PyObject * obj2 = 0 ;
7719 PyObject * obj3 = 0 ;
7720 char * kwnames[] = {
7721 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7722 };
7723
7724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7726 if (!SWIG_IsOK(res1)) {
7727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7728 }
7729 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7730 ecode2 = SWIG_AsVal_int(obj1, &val2);
7731 if (!SWIG_IsOK(ecode2)) {
7732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7733 }
7734 arg2 = static_cast< int >(val2);
7735 ecode3 = SWIG_AsVal_int(obj2, &val3);
7736 if (!SWIG_IsOK(ecode3)) {
7737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7738 }
7739 arg3 = static_cast< int >(val3);
7740 ecode4 = SWIG_AsVal_int(obj3, &val4);
7741 if (!SWIG_IsOK(ecode4)) {
7742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7743 }
7744 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj = 0;
7762 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7763 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7764 int arg3 ;
7765 int arg4 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 void *argp2 = 0 ;
7769 int res2 = 0 ;
7770 int val3 ;
7771 int ecode3 = 0 ;
7772 int val4 ;
7773 int ecode4 = 0 ;
7774 PyObject * obj0 = 0 ;
7775 PyObject * obj1 = 0 ;
7776 PyObject * obj2 = 0 ;
7777 PyObject * obj3 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7786 }
7787 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7789 if (!SWIG_IsOK(res2)) {
7790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7791 }
7792 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7793 ecode3 = SWIG_AsVal_int(obj2, &val3);
7794 if (!SWIG_IsOK(ecode3)) {
7795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7796 }
7797 arg3 = static_cast< int >(val3);
7798 ecode4 = SWIG_AsVal_int(obj3, &val4);
7799 if (!SWIG_IsOK(ecode4)) {
7800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7801 }
7802 arg4 = static_cast< int >(val4);
7803 {
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 (arg1)->SetAttr(arg2,arg3,arg4);
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 resultobj = SWIG_Py_Void();
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj = 0;
7818 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7819 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7820 int arg3 ;
7821 void *argp1 = 0 ;
7822 int res1 = 0 ;
7823 void *argp2 = 0 ;
7824 int res2 = 0 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "attr",(char *) "row", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7838 }
7839 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7841 if (!SWIG_IsOK(res2)) {
7842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7843 }
7844 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 (arg1)->SetRowAttr(arg2,arg3);
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_Py_Void();
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7864 PyObject *resultobj = 0;
7865 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7866 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7867 int arg3 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 void *argp2 = 0 ;
7871 int res2 = 0 ;
7872 int val3 ;
7873 int ecode3 = 0 ;
7874 PyObject * obj0 = 0 ;
7875 PyObject * obj1 = 0 ;
7876 PyObject * obj2 = 0 ;
7877 char * kwnames[] = {
7878 (char *) "self",(char *) "attr",(char *) "col", NULL
7879 };
7880
7881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7883 if (!SWIG_IsOK(res1)) {
7884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7885 }
7886 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7888 if (!SWIG_IsOK(res2)) {
7889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7890 }
7891 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7892 ecode3 = SWIG_AsVal_int(obj2, &val3);
7893 if (!SWIG_IsOK(ecode3)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7895 }
7896 arg3 = static_cast< int >(val3);
7897 {
7898 PyThreadState* __tstate = wxPyBeginAllowThreads();
7899 (arg1)->SetColAttr(arg2,arg3);
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_Py_Void();
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7911 PyObject *obj;
7912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7913 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7914 return SWIG_Py_Void();
7915 }
7916
7917 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7918 return SWIG_Python_InitShadowInstance(args);
7919 }
7920
7921 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7922 PyObject *resultobj = 0;
7923 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7924 void *argp1 = 0 ;
7925 int res1 = 0 ;
7926 PyObject *swig_obj[1] ;
7927
7928 if (!args) SWIG_fail;
7929 swig_obj[0] = args;
7930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7933 }
7934 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 delete arg1;
7938
7939 wxPyEndAllowThreads(__tstate);
7940 if (PyErr_Occurred()) SWIG_fail;
7941 }
7942 resultobj = SWIG_Py_Void();
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj = 0;
7951 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7952 PyObject *arg2 = (PyObject *) 0 ;
7953 void *argp1 = 0 ;
7954 int res1 = 0 ;
7955 PyObject * obj0 = 0 ;
7956 PyObject * obj1 = 0 ;
7957 char * kwnames[] = {
7958 (char *) "self",(char *) "_self", NULL
7959 };
7960
7961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7963 if (!SWIG_IsOK(res1)) {
7964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7965 }
7966 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7967 arg2 = obj1;
7968 {
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 wxGridTableBase__setOORInfo(arg1,arg2);
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 resultobj = SWIG_Py_Void();
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7982 PyObject *resultobj = 0;
7983 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7984 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7985 void *argp1 = 0 ;
7986 int res1 = 0 ;
7987 void *argp2 = 0 ;
7988 int res2 = 0 ;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 char * kwnames[] = {
7992 (char *) "self",(char *) "attrProvider", NULL
7993 };
7994
7995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7997 if (!SWIG_IsOK(res1)) {
7998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7999 }
8000 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8001 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8002 if (!SWIG_IsOK(res2)) {
8003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8004 }
8005 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8006 {
8007 PyThreadState* __tstate = wxPyBeginAllowThreads();
8008 (arg1)->SetAttrProvider(arg2);
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 resultobj = SWIG_Py_Void();
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 PyObject *resultobj = 0;
8021 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8022 wxGridCellAttrProvider *result = 0 ;
8023 void *argp1 = 0 ;
8024 int res1 = 0 ;
8025 PyObject *swig_obj[1] ;
8026
8027 if (!args) SWIG_fail;
8028 swig_obj[0] = args;
8029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8030 if (!SWIG_IsOK(res1)) {
8031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8032 }
8033 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 {
8041 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8042 }
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj = 0;
8051 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8052 wxGrid *arg2 = (wxGrid *) 0 ;
8053 void *argp1 = 0 ;
8054 int res1 = 0 ;
8055 void *argp2 = 0 ;
8056 int res2 = 0 ;
8057 PyObject * obj0 = 0 ;
8058 PyObject * obj1 = 0 ;
8059 char * kwnames[] = {
8060 (char *) "self",(char *) "grid", NULL
8061 };
8062
8063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8065 if (!SWIG_IsOK(res1)) {
8066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8067 }
8068 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8070 if (!SWIG_IsOK(res2)) {
8071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8072 }
8073 arg2 = reinterpret_cast< wxGrid * >(argp2);
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 (arg1)->SetView(arg2);
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8090 wxGrid *result = 0 ;
8091 void *argp1 = 0 ;
8092 int res1 = 0 ;
8093 PyObject *swig_obj[1] ;
8094
8095 if (!args) SWIG_fail;
8096 swig_obj[0] = args;
8097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8098 if (!SWIG_IsOK(res1)) {
8099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8100 }
8101 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 resultobj = wxPyMake_wxObject(result, (bool)0);
8110 }
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8118 PyObject *resultobj = 0;
8119 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8120 int result;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 PyObject *swig_obj[1] ;
8124
8125 if (!args) SWIG_fail;
8126 swig_obj[0] = args;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8130 }
8131 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 result = (int)(arg1)->GetNumberRows();
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8148 int result;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 PyObject *swig_obj[1] ;
8152
8153 if (!args) SWIG_fail;
8154 swig_obj[0] = args;
8155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8156 if (!SWIG_IsOK(res1)) {
8157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8158 }
8159 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8160 {
8161 PyThreadState* __tstate = wxPyBeginAllowThreads();
8162 result = (int)(arg1)->GetNumberCols();
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 resultobj = SWIG_From_int(static_cast< int >(result));
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj = 0;
8175 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8176 int arg2 ;
8177 int arg3 ;
8178 bool result;
8179 void *argp1 = 0 ;
8180 int res1 = 0 ;
8181 int val2 ;
8182 int ecode2 = 0 ;
8183 int val3 ;
8184 int ecode3 = 0 ;
8185 PyObject * obj0 = 0 ;
8186 PyObject * obj1 = 0 ;
8187 PyObject * obj2 = 0 ;
8188 char * kwnames[] = {
8189 (char *) "self",(char *) "row",(char *) "col", NULL
8190 };
8191
8192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8194 if (!SWIG_IsOK(res1)) {
8195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8196 }
8197 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8198 ecode2 = SWIG_AsVal_int(obj1, &val2);
8199 if (!SWIG_IsOK(ecode2)) {
8200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8201 }
8202 arg2 = static_cast< int >(val2);
8203 ecode3 = SWIG_AsVal_int(obj2, &val3);
8204 if (!SWIG_IsOK(ecode3)) {
8205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8206 }
8207 arg3 = static_cast< int >(val3);
8208 {
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 {
8215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8216 }
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = 0;
8225 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8226 int arg2 ;
8227 int arg3 ;
8228 wxString result;
8229 void *argp1 = 0 ;
8230 int res1 = 0 ;
8231 int val2 ;
8232 int ecode2 = 0 ;
8233 int val3 ;
8234 int ecode3 = 0 ;
8235 PyObject * obj0 = 0 ;
8236 PyObject * obj1 = 0 ;
8237 PyObject * obj2 = 0 ;
8238 char * kwnames[] = {
8239 (char *) "self",(char *) "row",(char *) "col", NULL
8240 };
8241
8242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8244 if (!SWIG_IsOK(res1)) {
8245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8246 }
8247 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8248 ecode2 = SWIG_AsVal_int(obj1, &val2);
8249 if (!SWIG_IsOK(ecode2)) {
8250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8251 }
8252 arg2 = static_cast< int >(val2);
8253 ecode3 = SWIG_AsVal_int(obj2, &val3);
8254 if (!SWIG_IsOK(ecode3)) {
8255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8256 }
8257 arg3 = static_cast< int >(val3);
8258 {
8259 PyThreadState* __tstate = wxPyBeginAllowThreads();
8260 result = (arg1)->GetValue(arg2,arg3);
8261 wxPyEndAllowThreads(__tstate);
8262 if (PyErr_Occurred()) SWIG_fail;
8263 }
8264 {
8265 #if wxUSE_UNICODE
8266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8267 #else
8268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8269 #endif
8270 }
8271 return resultobj;
8272 fail:
8273 return NULL;
8274 }
8275
8276
8277 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj = 0;
8279 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8280 int arg2 ;
8281 int arg3 ;
8282 wxString *arg4 = 0 ;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 int val2 ;
8286 int ecode2 = 0 ;
8287 int val3 ;
8288 int ecode3 = 0 ;
8289 bool temp4 = false ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 PyObject * obj2 = 0 ;
8293 PyObject * obj3 = 0 ;
8294 char * kwnames[] = {
8295 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8296 };
8297
8298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8300 if (!SWIG_IsOK(res1)) {
8301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8302 }
8303 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8304 ecode2 = SWIG_AsVal_int(obj1, &val2);
8305 if (!SWIG_IsOK(ecode2)) {
8306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8307 }
8308 arg2 = static_cast< int >(val2);
8309 ecode3 = SWIG_AsVal_int(obj2, &val3);
8310 if (!SWIG_IsOK(ecode3)) {
8311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8312 }
8313 arg3 = static_cast< int >(val3);
8314 {
8315 arg4 = wxString_in_helper(obj3);
8316 if (arg4 == NULL) SWIG_fail;
8317 temp4 = true;
8318 }
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 resultobj = SWIG_Py_Void();
8326 {
8327 if (temp4)
8328 delete arg4;
8329 }
8330 return resultobj;
8331 fail:
8332 {
8333 if (temp4)
8334 delete arg4;
8335 }
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8343 int arg2 ;
8344 int arg3 ;
8345 wxString result;
8346 void *argp1 = 0 ;
8347 int res1 = 0 ;
8348 int val2 ;
8349 int ecode2 = 0 ;
8350 int val3 ;
8351 int ecode3 = 0 ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 PyObject * obj2 = 0 ;
8355 char * kwnames[] = {
8356 (char *) "self",(char *) "row",(char *) "col", NULL
8357 };
8358
8359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8363 }
8364 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8365 ecode2 = SWIG_AsVal_int(obj1, &val2);
8366 if (!SWIG_IsOK(ecode2)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8368 }
8369 arg2 = static_cast< int >(val2);
8370 ecode3 = SWIG_AsVal_int(obj2, &val3);
8371 if (!SWIG_IsOK(ecode3)) {
8372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8373 }
8374 arg3 = static_cast< int >(val3);
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 result = (arg1)->GetTypeName(arg2,arg3);
8378 wxPyEndAllowThreads(__tstate);
8379 if (PyErr_Occurred()) SWIG_fail;
8380 }
8381 {
8382 #if wxUSE_UNICODE
8383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8384 #else
8385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8386 #endif
8387 }
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8395 PyObject *resultobj = 0;
8396 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8397 int arg2 ;
8398 int arg3 ;
8399 wxString *arg4 = 0 ;
8400 bool result;
8401 void *argp1 = 0 ;
8402 int res1 = 0 ;
8403 int val2 ;
8404 int ecode2 = 0 ;
8405 int val3 ;
8406 int ecode3 = 0 ;
8407 bool temp4 = false ;
8408 PyObject * obj0 = 0 ;
8409 PyObject * obj1 = 0 ;
8410 PyObject * obj2 = 0 ;
8411 PyObject * obj3 = 0 ;
8412 char * kwnames[] = {
8413 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8414 };
8415
8416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8418 if (!SWIG_IsOK(res1)) {
8419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8420 }
8421 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8422 ecode2 = SWIG_AsVal_int(obj1, &val2);
8423 if (!SWIG_IsOK(ecode2)) {
8424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8425 }
8426 arg2 = static_cast< int >(val2);
8427 ecode3 = SWIG_AsVal_int(obj2, &val3);
8428 if (!SWIG_IsOK(ecode3)) {
8429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8430 }
8431 arg3 = static_cast< int >(val3);
8432 {
8433 arg4 = wxString_in_helper(obj3);
8434 if (arg4 == NULL) SWIG_fail;
8435 temp4 = true;
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 {
8444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8445 }
8446 {
8447 if (temp4)
8448 delete arg4;
8449 }
8450 return resultobj;
8451 fail:
8452 {
8453 if (temp4)
8454 delete arg4;
8455 }
8456 return NULL;
8457 }
8458
8459
8460 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8461 PyObject *resultobj = 0;
8462 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8463 int arg2 ;
8464 int arg3 ;
8465 wxString *arg4 = 0 ;
8466 bool result;
8467 void *argp1 = 0 ;
8468 int res1 = 0 ;
8469 int val2 ;
8470 int ecode2 = 0 ;
8471 int val3 ;
8472 int ecode3 = 0 ;
8473 bool temp4 = false ;
8474 PyObject * obj0 = 0 ;
8475 PyObject * obj1 = 0 ;
8476 PyObject * obj2 = 0 ;
8477 PyObject * obj3 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8486 }
8487 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8488 ecode2 = SWIG_AsVal_int(obj1, &val2);
8489 if (!SWIG_IsOK(ecode2)) {
8490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8491 }
8492 arg2 = static_cast< int >(val2);
8493 ecode3 = SWIG_AsVal_int(obj2, &val3);
8494 if (!SWIG_IsOK(ecode3)) {
8495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8496 }
8497 arg3 = static_cast< int >(val3);
8498 {
8499 arg4 = wxString_in_helper(obj3);
8500 if (arg4 == NULL) SWIG_fail;
8501 temp4 = true;
8502 }
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8511 }
8512 {
8513 if (temp4)
8514 delete arg4;
8515 }
8516 return resultobj;
8517 fail:
8518 {
8519 if (temp4)
8520 delete arg4;
8521 }
8522 return NULL;
8523 }
8524
8525
8526 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8527 PyObject *resultobj = 0;
8528 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8529 int arg2 ;
8530 int arg3 ;
8531 long result;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 int val2 ;
8535 int ecode2 = 0 ;
8536 int val3 ;
8537 int ecode3 = 0 ;
8538 PyObject * obj0 = 0 ;
8539 PyObject * obj1 = 0 ;
8540 PyObject * obj2 = 0 ;
8541 char * kwnames[] = {
8542 (char *) "self",(char *) "row",(char *) "col", NULL
8543 };
8544
8545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8549 }
8550 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8551 ecode2 = SWIG_AsVal_int(obj1, &val2);
8552 if (!SWIG_IsOK(ecode2)) {
8553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8554 }
8555 arg2 = static_cast< int >(val2);
8556 ecode3 = SWIG_AsVal_int(obj2, &val3);
8557 if (!SWIG_IsOK(ecode3)) {
8558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8559 }
8560 arg3 = static_cast< int >(val3);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_From_long(static_cast< long >(result));
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8577 int arg2 ;
8578 int arg3 ;
8579 double result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 int val2 ;
8583 int ecode2 = 0 ;
8584 int val3 ;
8585 int ecode3 = 0 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 PyObject * obj2 = 0 ;
8589 char * kwnames[] = {
8590 (char *) "self",(char *) "row",(char *) "col", NULL
8591 };
8592
8593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8595 if (!SWIG_IsOK(res1)) {
8596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8597 }
8598 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8599 ecode2 = SWIG_AsVal_int(obj1, &val2);
8600 if (!SWIG_IsOK(ecode2)) {
8601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8602 }
8603 arg2 = static_cast< int >(val2);
8604 ecode3 = SWIG_AsVal_int(obj2, &val3);
8605 if (!SWIG_IsOK(ecode3)) {
8606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8607 }
8608 arg3 = static_cast< int >(val3);
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 resultobj = SWIG_From_double(static_cast< double >(result));
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8623 PyObject *resultobj = 0;
8624 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8625 int arg2 ;
8626 int arg3 ;
8627 bool result;
8628 void *argp1 = 0 ;
8629 int res1 = 0 ;
8630 int val2 ;
8631 int ecode2 = 0 ;
8632 int val3 ;
8633 int ecode3 = 0 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 PyObject * obj2 = 0 ;
8637 char * kwnames[] = {
8638 (char *) "self",(char *) "row",(char *) "col", NULL
8639 };
8640
8641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8645 }
8646 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8647 ecode2 = SWIG_AsVal_int(obj1, &val2);
8648 if (!SWIG_IsOK(ecode2)) {
8649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8650 }
8651 arg2 = static_cast< int >(val2);
8652 ecode3 = SWIG_AsVal_int(obj2, &val3);
8653 if (!SWIG_IsOK(ecode3)) {
8654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8655 }
8656 arg3 = static_cast< int >(val3);
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8665 }
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj = 0;
8674 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8675 int arg2 ;
8676 int arg3 ;
8677 long arg4 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 int val2 ;
8681 int ecode2 = 0 ;
8682 int val3 ;
8683 int ecode3 = 0 ;
8684 long val4 ;
8685 int ecode4 = 0 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 PyObject * obj2 = 0 ;
8689 PyObject * obj3 = 0 ;
8690 char * kwnames[] = {
8691 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8692 };
8693
8694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8698 }
8699 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8700 ecode2 = SWIG_AsVal_int(obj1, &val2);
8701 if (!SWIG_IsOK(ecode2)) {
8702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8703 }
8704 arg2 = static_cast< int >(val2);
8705 ecode3 = SWIG_AsVal_int(obj2, &val3);
8706 if (!SWIG_IsOK(ecode3)) {
8707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8708 }
8709 arg3 = static_cast< int >(val3);
8710 ecode4 = SWIG_AsVal_long(obj3, &val4);
8711 if (!SWIG_IsOK(ecode4)) {
8712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8713 }
8714 arg4 = static_cast< long >(val4);
8715 {
8716 PyThreadState* __tstate = wxPyBeginAllowThreads();
8717 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8718 wxPyEndAllowThreads(__tstate);
8719 if (PyErr_Occurred()) SWIG_fail;
8720 }
8721 resultobj = SWIG_Py_Void();
8722 return resultobj;
8723 fail:
8724 return NULL;
8725 }
8726
8727
8728 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj = 0;
8730 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8731 int arg2 ;
8732 int arg3 ;
8733 double arg4 ;
8734 void *argp1 = 0 ;
8735 int res1 = 0 ;
8736 int val2 ;
8737 int ecode2 = 0 ;
8738 int val3 ;
8739 int ecode3 = 0 ;
8740 double val4 ;
8741 int ecode4 = 0 ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745 PyObject * obj3 = 0 ;
8746 char * kwnames[] = {
8747 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8748 };
8749
8750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8752 if (!SWIG_IsOK(res1)) {
8753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8754 }
8755 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8756 ecode2 = SWIG_AsVal_int(obj1, &val2);
8757 if (!SWIG_IsOK(ecode2)) {
8758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8759 }
8760 arg2 = static_cast< int >(val2);
8761 ecode3 = SWIG_AsVal_int(obj2, &val3);
8762 if (!SWIG_IsOK(ecode3)) {
8763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8764 }
8765 arg3 = static_cast< int >(val3);
8766 ecode4 = SWIG_AsVal_double(obj3, &val4);
8767 if (!SWIG_IsOK(ecode4)) {
8768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8769 }
8770 arg4 = static_cast< double >(val4);
8771 {
8772 PyThreadState* __tstate = wxPyBeginAllowThreads();
8773 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 resultobj = SWIG_Py_Void();
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj = 0;
8786 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8787 int arg2 ;
8788 int arg3 ;
8789 bool arg4 ;
8790 void *argp1 = 0 ;
8791 int res1 = 0 ;
8792 int val2 ;
8793 int ecode2 = 0 ;
8794 int val3 ;
8795 int ecode3 = 0 ;
8796 bool val4 ;
8797 int ecode4 = 0 ;
8798 PyObject * obj0 = 0 ;
8799 PyObject * obj1 = 0 ;
8800 PyObject * obj2 = 0 ;
8801 PyObject * obj3 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8810 }
8811 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8812 ecode2 = SWIG_AsVal_int(obj1, &val2);
8813 if (!SWIG_IsOK(ecode2)) {
8814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8815 }
8816 arg2 = static_cast< int >(val2);
8817 ecode3 = SWIG_AsVal_int(obj2, &val3);
8818 if (!SWIG_IsOK(ecode3)) {
8819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8820 }
8821 arg3 = static_cast< int >(val3);
8822 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8823 if (!SWIG_IsOK(ecode4)) {
8824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8825 }
8826 arg4 = static_cast< bool >(val4);
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 resultobj = SWIG_Py_Void();
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8841 PyObject *resultobj = 0;
8842 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 PyObject *swig_obj[1] ;
8846
8847 if (!args) SWIG_fail;
8848 swig_obj[0] = args;
8849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8852 }
8853 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 (arg1)->Clear();
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 resultobj = SWIG_Py_Void();
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj = 0;
8869 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8870 size_t arg2 = (size_t) 0 ;
8871 size_t arg3 = (size_t) 1 ;
8872 bool result;
8873 void *argp1 = 0 ;
8874 int res1 = 0 ;
8875 size_t val2 ;
8876 int ecode2 = 0 ;
8877 size_t val3 ;
8878 int ecode3 = 0 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 PyObject * obj2 = 0 ;
8882 char * kwnames[] = {
8883 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8890 }
8891 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8892 if (obj1) {
8893 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8894 if (!SWIG_IsOK(ecode2)) {
8895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8896 }
8897 arg2 = static_cast< size_t >(val2);
8898 }
8899 if (obj2) {
8900 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8901 if (!SWIG_IsOK(ecode3)) {
8902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8903 }
8904 arg3 = static_cast< size_t >(val3);
8905 }
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 result = (bool)(arg1)->InsertRows(arg2,arg3);
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 {
8913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8914 }
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj = 0;
8923 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8924 size_t arg2 = (size_t) 1 ;
8925 bool result;
8926 void *argp1 = 0 ;
8927 int res1 = 0 ;
8928 size_t val2 ;
8929 int ecode2 = 0 ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 char * kwnames[] = {
8933 (char *) "self",(char *) "numRows", NULL
8934 };
8935
8936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8938 if (!SWIG_IsOK(res1)) {
8939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8940 }
8941 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8942 if (obj1) {
8943 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8944 if (!SWIG_IsOK(ecode2)) {
8945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8946 }
8947 arg2 = static_cast< size_t >(val2);
8948 }
8949 {
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 result = (bool)(arg1)->AppendRows(arg2);
8952 wxPyEndAllowThreads(__tstate);
8953 if (PyErr_Occurred()) SWIG_fail;
8954 }
8955 {
8956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8957 }
8958 return resultobj;
8959 fail:
8960 return NULL;
8961 }
8962
8963
8964 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8965 PyObject *resultobj = 0;
8966 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8967 size_t arg2 = (size_t) 0 ;
8968 size_t arg3 = (size_t) 1 ;
8969 bool result;
8970 void *argp1 = 0 ;
8971 int res1 = 0 ;
8972 size_t val2 ;
8973 int ecode2 = 0 ;
8974 size_t val3 ;
8975 int ecode3 = 0 ;
8976 PyObject * obj0 = 0 ;
8977 PyObject * obj1 = 0 ;
8978 PyObject * obj2 = 0 ;
8979 char * kwnames[] = {
8980 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8981 };
8982
8983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8985 if (!SWIG_IsOK(res1)) {
8986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8987 }
8988 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8989 if (obj1) {
8990 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8991 if (!SWIG_IsOK(ecode2)) {
8992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8993 }
8994 arg2 = static_cast< size_t >(val2);
8995 }
8996 if (obj2) {
8997 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8998 if (!SWIG_IsOK(ecode3)) {
8999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
9000 }
9001 arg3 = static_cast< size_t >(val3);
9002 }
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 {
9010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj = 0;
9020 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9021 size_t arg2 = (size_t) 0 ;
9022 size_t arg3 = (size_t) 1 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 size_t val2 ;
9027 int ecode2 = 0 ;
9028 size_t val3 ;
9029 int ecode3 = 0 ;
9030 PyObject * obj0 = 0 ;
9031 PyObject * obj1 = 0 ;
9032 PyObject * obj2 = 0 ;
9033 char * kwnames[] = {
9034 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9035 };
9036
9037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9041 }
9042 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9043 if (obj1) {
9044 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9045 if (!SWIG_IsOK(ecode2)) {
9046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9047 }
9048 arg2 = static_cast< size_t >(val2);
9049 }
9050 if (obj2) {
9051 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9052 if (!SWIG_IsOK(ecode3)) {
9053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9054 }
9055 arg3 = static_cast< size_t >(val3);
9056 }
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = (bool)(arg1)->InsertCols(arg2,arg3);
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 {
9064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9065 }
9066 return resultobj;
9067 fail:
9068 return NULL;
9069 }
9070
9071
9072 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9073 PyObject *resultobj = 0;
9074 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9075 size_t arg2 = (size_t) 1 ;
9076 bool result;
9077 void *argp1 = 0 ;
9078 int res1 = 0 ;
9079 size_t val2 ;
9080 int ecode2 = 0 ;
9081 PyObject * obj0 = 0 ;
9082 PyObject * obj1 = 0 ;
9083 char * kwnames[] = {
9084 (char *) "self",(char *) "numCols", NULL
9085 };
9086
9087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9091 }
9092 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9093 if (obj1) {
9094 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9095 if (!SWIG_IsOK(ecode2)) {
9096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9097 }
9098 arg2 = static_cast< size_t >(val2);
9099 }
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (bool)(arg1)->AppendCols(arg2);
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 {
9107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9108 }
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj = 0;
9117 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9118 size_t arg2 = (size_t) 0 ;
9119 size_t arg3 = (size_t) 1 ;
9120 bool result;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 size_t val2 ;
9124 int ecode2 = 0 ;
9125 size_t val3 ;
9126 int ecode3 = 0 ;
9127 PyObject * obj0 = 0 ;
9128 PyObject * obj1 = 0 ;
9129 PyObject * obj2 = 0 ;
9130 char * kwnames[] = {
9131 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9132 };
9133
9134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9136 if (!SWIG_IsOK(res1)) {
9137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9138 }
9139 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9140 if (obj1) {
9141 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9142 if (!SWIG_IsOK(ecode2)) {
9143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9144 }
9145 arg2 = static_cast< size_t >(val2);
9146 }
9147 if (obj2) {
9148 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9149 if (!SWIG_IsOK(ecode3)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9151 }
9152 arg3 = static_cast< size_t >(val3);
9153 }
9154 {
9155 PyThreadState* __tstate = wxPyBeginAllowThreads();
9156 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 {
9161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9162 }
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj = 0;
9171 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9172 int arg2 ;
9173 wxString result;
9174 void *argp1 = 0 ;
9175 int res1 = 0 ;
9176 int val2 ;
9177 int ecode2 = 0 ;
9178 PyObject * obj0 = 0 ;
9179 PyObject * obj1 = 0 ;
9180 char * kwnames[] = {
9181 (char *) "self",(char *) "row", NULL
9182 };
9183
9184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9186 if (!SWIG_IsOK(res1)) {
9187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9188 }
9189 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9190 ecode2 = SWIG_AsVal_int(obj1, &val2);
9191 if (!SWIG_IsOK(ecode2)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9193 }
9194 arg2 = static_cast< int >(val2);
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (arg1)->GetRowLabelValue(arg2);
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 {
9202 #if wxUSE_UNICODE
9203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9204 #else
9205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9206 #endif
9207 }
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9215 PyObject *resultobj = 0;
9216 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9217 int arg2 ;
9218 wxString result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 int val2 ;
9222 int ecode2 = 0 ;
9223 PyObject * obj0 = 0 ;
9224 PyObject * obj1 = 0 ;
9225 char * kwnames[] = {
9226 (char *) "self",(char *) "col", NULL
9227 };
9228
9229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9231 if (!SWIG_IsOK(res1)) {
9232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9233 }
9234 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9235 ecode2 = SWIG_AsVal_int(obj1, &val2);
9236 if (!SWIG_IsOK(ecode2)) {
9237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9238 }
9239 arg2 = static_cast< int >(val2);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (arg1)->GetColLabelValue(arg2);
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 {
9247 #if wxUSE_UNICODE
9248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9249 #else
9250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9251 #endif
9252 }
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj = 0;
9261 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9262 int arg2 ;
9263 wxString *arg3 = 0 ;
9264 void *argp1 = 0 ;
9265 int res1 = 0 ;
9266 int val2 ;
9267 int ecode2 = 0 ;
9268 bool temp3 = false ;
9269 PyObject * obj0 = 0 ;
9270 PyObject * obj1 = 0 ;
9271 PyObject * obj2 = 0 ;
9272 char * kwnames[] = {
9273 (char *) "self",(char *) "row",(char *) "value", NULL
9274 };
9275
9276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9278 if (!SWIG_IsOK(res1)) {
9279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9280 }
9281 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9282 ecode2 = SWIG_AsVal_int(obj1, &val2);
9283 if (!SWIG_IsOK(ecode2)) {
9284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9285 }
9286 arg2 = static_cast< int >(val2);
9287 {
9288 arg3 = wxString_in_helper(obj2);
9289 if (arg3 == NULL) SWIG_fail;
9290 temp3 = true;
9291 }
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_Py_Void();
9299 {
9300 if (temp3)
9301 delete arg3;
9302 }
9303 return resultobj;
9304 fail:
9305 {
9306 if (temp3)
9307 delete arg3;
9308 }
9309 return NULL;
9310 }
9311
9312
9313 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj = 0;
9315 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9316 int arg2 ;
9317 wxString *arg3 = 0 ;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 int val2 ;
9321 int ecode2 = 0 ;
9322 bool temp3 = false ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 PyObject * obj2 = 0 ;
9326 char * kwnames[] = {
9327 (char *) "self",(char *) "col",(char *) "value", NULL
9328 };
9329
9330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9332 if (!SWIG_IsOK(res1)) {
9333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9334 }
9335 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9336 ecode2 = SWIG_AsVal_int(obj1, &val2);
9337 if (!SWIG_IsOK(ecode2)) {
9338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9339 }
9340 arg2 = static_cast< int >(val2);
9341 {
9342 arg3 = wxString_in_helper(obj2);
9343 if (arg3 == NULL) SWIG_fail;
9344 temp3 = true;
9345 }
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_Py_Void();
9353 {
9354 if (temp3)
9355 delete arg3;
9356 }
9357 return resultobj;
9358 fail:
9359 {
9360 if (temp3)
9361 delete arg3;
9362 }
9363 return NULL;
9364 }
9365
9366
9367 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9368 PyObject *resultobj = 0;
9369 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9370 bool result;
9371 void *argp1 = 0 ;
9372 int res1 = 0 ;
9373 PyObject *swig_obj[1] ;
9374
9375 if (!args) SWIG_fail;
9376 swig_obj[0] = args;
9377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9378 if (!SWIG_IsOK(res1)) {
9379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9380 }
9381 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (bool)(arg1)->CanHaveAttributes();
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 {
9389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9400 int arg2 ;
9401 int arg3 ;
9402 wxGridCellAttr::wxAttrKind arg4 ;
9403 wxGridCellAttr *result = 0 ;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 int val2 ;
9407 int ecode2 = 0 ;
9408 int val3 ;
9409 int ecode3 = 0 ;
9410 int val4 ;
9411 int ecode4 = 0 ;
9412 PyObject * obj0 = 0 ;
9413 PyObject * obj1 = 0 ;
9414 PyObject * obj2 = 0 ;
9415 PyObject * obj3 = 0 ;
9416 char * kwnames[] = {
9417 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9418 };
9419
9420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9422 if (!SWIG_IsOK(res1)) {
9423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9424 }
9425 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9426 ecode2 = SWIG_AsVal_int(obj1, &val2);
9427 if (!SWIG_IsOK(ecode2)) {
9428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9429 }
9430 arg2 = static_cast< int >(val2);
9431 ecode3 = SWIG_AsVal_int(obj2, &val3);
9432 if (!SWIG_IsOK(ecode3)) {
9433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9434 }
9435 arg3 = static_cast< int >(val3);
9436 ecode4 = SWIG_AsVal_int(obj3, &val4);
9437 if (!SWIG_IsOK(ecode4)) {
9438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9439 }
9440 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9441 {
9442 PyThreadState* __tstate = wxPyBeginAllowThreads();
9443 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 {
9448 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9449 }
9450 return resultobj;
9451 fail:
9452 return NULL;
9453 }
9454
9455
9456 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj = 0;
9458 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9459 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9460 int arg3 ;
9461 int arg4 ;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 void *argp2 = 0 ;
9465 int res2 = 0 ;
9466 int val3 ;
9467 int ecode3 = 0 ;
9468 int val4 ;
9469 int ecode4 = 0 ;
9470 PyObject * obj0 = 0 ;
9471 PyObject * obj1 = 0 ;
9472 PyObject * obj2 = 0 ;
9473 PyObject * obj3 = 0 ;
9474 char * kwnames[] = {
9475 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9476 };
9477
9478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9482 }
9483 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9485 if (!SWIG_IsOK(res2)) {
9486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9487 }
9488 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9489 ecode3 = SWIG_AsVal_int(obj2, &val3);
9490 if (!SWIG_IsOK(ecode3)) {
9491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9492 }
9493 arg3 = static_cast< int >(val3);
9494 ecode4 = SWIG_AsVal_int(obj3, &val4);
9495 if (!SWIG_IsOK(ecode4)) {
9496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9497 }
9498 arg4 = static_cast< int >(val4);
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 (arg1)->SetAttr(arg2,arg3,arg4);
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 resultobj = SWIG_Py_Void();
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj = 0;
9514 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9515 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9516 int arg3 ;
9517 void *argp1 = 0 ;
9518 int res1 = 0 ;
9519 void *argp2 = 0 ;
9520 int res2 = 0 ;
9521 int val3 ;
9522 int ecode3 = 0 ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 PyObject * obj2 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "attr",(char *) "row", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9534 }
9535 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9537 if (!SWIG_IsOK(res2)) {
9538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9539 }
9540 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9541 ecode3 = SWIG_AsVal_int(obj2, &val3);
9542 if (!SWIG_IsOK(ecode3)) {
9543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9544 }
9545 arg3 = static_cast< int >(val3);
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 (arg1)->SetRowAttr(arg2,arg3);
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9562 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9563 int arg3 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 void *argp2 = 0 ;
9567 int res2 = 0 ;
9568 int val3 ;
9569 int ecode3 = 0 ;
9570 PyObject * obj0 = 0 ;
9571 PyObject * obj1 = 0 ;
9572 PyObject * obj2 = 0 ;
9573 char * kwnames[] = {
9574 (char *) "self",(char *) "attr",(char *) "col", NULL
9575 };
9576
9577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9579 if (!SWIG_IsOK(res1)) {
9580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9581 }
9582 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9584 if (!SWIG_IsOK(res2)) {
9585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9586 }
9587 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9588 ecode3 = SWIG_AsVal_int(obj2, &val3);
9589 if (!SWIG_IsOK(ecode3)) {
9590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9591 }
9592 arg3 = static_cast< int >(val3);
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 (arg1)->SetColAttr(arg2,arg3);
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_Py_Void();
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9607 PyObject *obj;
9608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9609 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9610 return SWIG_Py_Void();
9611 }
9612
9613 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9614 PyObject *resultobj = 0;
9615 wxPyGridTableBase *result = 0 ;
9616
9617 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9618 {
9619 PyThreadState* __tstate = wxPyBeginAllowThreads();
9620 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9621 wxPyEndAllowThreads(__tstate);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj = 0;
9633 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9634 PyObject *arg2 = (PyObject *) 0 ;
9635 PyObject *arg3 = (PyObject *) 0 ;
9636 void *argp1 = 0 ;
9637 int res1 = 0 ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 PyObject * obj2 = 0 ;
9641 char * kwnames[] = {
9642 (char *) "self",(char *) "self",(char *) "_class", NULL
9643 };
9644
9645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9647 if (!SWIG_IsOK(res1)) {
9648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9649 }
9650 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9651 arg2 = obj1;
9652 arg3 = obj2;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->_setCallbackInfo(arg2,arg3);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9678 }
9679 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 wxPyGridTableBase_Destroy(arg1);
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_Py_Void();
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9694 PyObject *obj;
9695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9696 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9697 return SWIG_Py_Void();
9698 }
9699
9700 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9701 return SWIG_Python_InitShadowInstance(args);
9702 }
9703
9704 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj = 0;
9706 int arg1 = (int) 0 ;
9707 int arg2 = (int) 0 ;
9708 wxGridStringTable *result = 0 ;
9709 int val1 ;
9710 int ecode1 = 0 ;
9711 int val2 ;
9712 int ecode2 = 0 ;
9713 PyObject * obj0 = 0 ;
9714 PyObject * obj1 = 0 ;
9715 char * kwnames[] = {
9716 (char *) "numRows",(char *) "numCols", NULL
9717 };
9718
9719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9720 if (obj0) {
9721 ecode1 = SWIG_AsVal_int(obj0, &val1);
9722 if (!SWIG_IsOK(ecode1)) {
9723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9724 }
9725 arg1 = static_cast< int >(val1);
9726 }
9727 if (obj1) {
9728 ecode2 = SWIG_AsVal_int(obj1, &val2);
9729 if (!SWIG_IsOK(ecode2)) {
9730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9731 }
9732 arg2 = static_cast< int >(val2);
9733 }
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9737 wxPyEndAllowThreads(__tstate);
9738 if (PyErr_Occurred()) SWIG_fail;
9739 }
9740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9748 PyObject *obj;
9749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9750 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9751 return SWIG_Py_Void();
9752 }
9753
9754 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755 return SWIG_Python_InitShadowInstance(args);
9756 }
9757
9758 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj = 0;
9760 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9761 int arg2 ;
9762 int arg3 = (int) -1 ;
9763 int arg4 = (int) -1 ;
9764 wxGridTableMessage *result = 0 ;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 int val2 ;
9768 int ecode2 = 0 ;
9769 int val3 ;
9770 int ecode3 = 0 ;
9771 int val4 ;
9772 int ecode4 = 0 ;
9773 PyObject * obj0 = 0 ;
9774 PyObject * obj1 = 0 ;
9775 PyObject * obj2 = 0 ;
9776 PyObject * obj3 = 0 ;
9777 char * kwnames[] = {
9778 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9779 };
9780
9781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9785 }
9786 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9787 ecode2 = SWIG_AsVal_int(obj1, &val2);
9788 if (!SWIG_IsOK(ecode2)) {
9789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9790 }
9791 arg2 = static_cast< int >(val2);
9792 if (obj2) {
9793 ecode3 = SWIG_AsVal_int(obj2, &val3);
9794 if (!SWIG_IsOK(ecode3)) {
9795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9796 }
9797 arg3 = static_cast< int >(val3);
9798 }
9799 if (obj3) {
9800 ecode4 = SWIG_AsVal_int(obj3, &val4);
9801 if (!SWIG_IsOK(ecode4)) {
9802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9803 }
9804 arg4 = static_cast< int >(val4);
9805 }
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9820 PyObject *resultobj = 0;
9821 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9822 void *argp1 = 0 ;
9823 int res1 = 0 ;
9824 PyObject *swig_obj[1] ;
9825
9826 if (!args) SWIG_fail;
9827 swig_obj[0] = args;
9828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9829 if (!SWIG_IsOK(res1)) {
9830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9831 }
9832 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 delete arg1;
9836
9837 wxPyEndAllowThreads(__tstate);
9838 if (PyErr_Occurred()) SWIG_fail;
9839 }
9840 resultobj = SWIG_Py_Void();
9841 return resultobj;
9842 fail:
9843 return NULL;
9844 }
9845
9846
9847 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9848 PyObject *resultobj = 0;
9849 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9850 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9851 void *argp1 = 0 ;
9852 int res1 = 0 ;
9853 void *argp2 = 0 ;
9854 int res2 = 0 ;
9855 PyObject * obj0 = 0 ;
9856 PyObject * obj1 = 0 ;
9857 char * kwnames[] = {
9858 (char *) "self",(char *) "table", NULL
9859 };
9860
9861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9863 if (!SWIG_IsOK(res1)) {
9864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9865 }
9866 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9868 if (!SWIG_IsOK(res2)) {
9869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9870 }
9871 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 (arg1)->SetTableObject(arg2);
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 resultobj = SWIG_Py_Void();
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886 PyObject *resultobj = 0;
9887 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9888 wxGridTableBase *result = 0 ;
9889 void *argp1 = 0 ;
9890 int res1 = 0 ;
9891 PyObject *swig_obj[1] ;
9892
9893 if (!args) SWIG_fail;
9894 swig_obj[0] = args;
9895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9898 }
9899 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9908 }
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9918 int arg2 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 int val2 ;
9922 int ecode2 = 0 ;
9923 PyObject * obj0 = 0 ;
9924 PyObject * obj1 = 0 ;
9925 char * kwnames[] = {
9926 (char *) "self",(char *) "id", NULL
9927 };
9928
9929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9931 if (!SWIG_IsOK(res1)) {
9932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9933 }
9934 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9935 ecode2 = SWIG_AsVal_int(obj1, &val2);
9936 if (!SWIG_IsOK(ecode2)) {
9937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9938 }
9939 arg2 = static_cast< int >(val2);
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 (arg1)->SetId(arg2);
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 resultobj = SWIG_Py_Void();
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 PyObject *resultobj = 0;
9955 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9956 int result;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 PyObject *swig_obj[1] ;
9960
9961 if (!args) SWIG_fail;
9962 swig_obj[0] = args;
9963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9964 if (!SWIG_IsOK(res1)) {
9965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9966 }
9967 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (int)(arg1)->GetId();
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 resultobj = SWIG_From_int(static_cast< int >(result));
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9982 PyObject *resultobj = 0;
9983 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9984 int arg2 ;
9985 void *argp1 = 0 ;
9986 int res1 = 0 ;
9987 int val2 ;
9988 int ecode2 = 0 ;
9989 PyObject * obj0 = 0 ;
9990 PyObject * obj1 = 0 ;
9991 char * kwnames[] = {
9992 (char *) "self",(char *) "comInt1", NULL
9993 };
9994
9995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9997 if (!SWIG_IsOK(res1)) {
9998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9999 }
10000 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10001 ecode2 = SWIG_AsVal_int(obj1, &val2);
10002 if (!SWIG_IsOK(ecode2)) {
10003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10004 }
10005 arg2 = static_cast< int >(val2);
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 (arg1)->SetCommandInt(arg2);
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_Py_Void();
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10022 int result;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 PyObject *swig_obj[1] ;
10026
10027 if (!args) SWIG_fail;
10028 swig_obj[0] = args;
10029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10032 }
10033 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 result = (int)(arg1)->GetCommandInt();
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 resultobj = SWIG_From_int(static_cast< int >(result));
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = 0;
10049 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10050 int arg2 ;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 int val2 ;
10054 int ecode2 = 0 ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 char * kwnames[] = {
10058 (char *) "self",(char *) "comInt2", NULL
10059 };
10060
10061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10065 }
10066 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10067 ecode2 = SWIG_AsVal_int(obj1, &val2);
10068 if (!SWIG_IsOK(ecode2)) {
10069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10070 }
10071 arg2 = static_cast< int >(val2);
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 (arg1)->SetCommandInt2(arg2);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 resultobj = SWIG_Py_Void();
10079 return resultobj;
10080 fail:
10081 return NULL;
10082 }
10083
10084
10085 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10086 PyObject *resultobj = 0;
10087 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10088 int result;
10089 void *argp1 = 0 ;
10090 int res1 = 0 ;
10091 PyObject *swig_obj[1] ;
10092
10093 if (!args) SWIG_fail;
10094 swig_obj[0] = args;
10095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10098 }
10099 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10100 {
10101 PyThreadState* __tstate = wxPyBeginAllowThreads();
10102 result = (int)(arg1)->GetCommandInt2();
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 resultobj = SWIG_From_int(static_cast< int >(result));
10107 return resultobj;
10108 fail:
10109 return NULL;
10110 }
10111
10112
10113 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10114 PyObject *obj;
10115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10116 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10117 return SWIG_Py_Void();
10118 }
10119
10120 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10121 return SWIG_Python_InitShadowInstance(args);
10122 }
10123
10124 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj = 0;
10126 int arg1 = (int) -1 ;
10127 int arg2 = (int) -1 ;
10128 wxGridCellCoords *result = 0 ;
10129 int val1 ;
10130 int ecode1 = 0 ;
10131 int val2 ;
10132 int ecode2 = 0 ;
10133 PyObject * obj0 = 0 ;
10134 PyObject * obj1 = 0 ;
10135 char * kwnames[] = {
10136 (char *) "r",(char *) "c", NULL
10137 };
10138
10139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10140 if (obj0) {
10141 ecode1 = SWIG_AsVal_int(obj0, &val1);
10142 if (!SWIG_IsOK(ecode1)) {
10143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10144 }
10145 arg1 = static_cast< int >(val1);
10146 }
10147 if (obj1) {
10148 ecode2 = SWIG_AsVal_int(obj1, &val2);
10149 if (!SWIG_IsOK(ecode2)) {
10150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10151 }
10152 arg2 = static_cast< int >(val2);
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10161 return resultobj;
10162 fail:
10163 return NULL;
10164 }
10165
10166
10167 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10168 PyObject *resultobj = 0;
10169 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10170 void *argp1 = 0 ;
10171 int res1 = 0 ;
10172 PyObject *swig_obj[1] ;
10173
10174 if (!args) SWIG_fail;
10175 swig_obj[0] = args;
10176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10179 }
10180 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10181 {
10182 PyThreadState* __tstate = wxPyBeginAllowThreads();
10183 delete arg1;
10184
10185 wxPyEndAllowThreads(__tstate);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 resultobj = SWIG_Py_Void();
10189 return resultobj;
10190 fail:
10191 return NULL;
10192 }
10193
10194
10195 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10196 PyObject *resultobj = 0;
10197 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10198 int result;
10199 void *argp1 = 0 ;
10200 int res1 = 0 ;
10201 PyObject *swig_obj[1] ;
10202
10203 if (!args) SWIG_fail;
10204 swig_obj[0] = args;
10205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10206 if (!SWIG_IsOK(res1)) {
10207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10208 }
10209 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 resultobj = SWIG_From_int(static_cast< int >(result));
10217 return resultobj;
10218 fail:
10219 return NULL;
10220 }
10221
10222
10223 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj = 0;
10225 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10226 int arg2 ;
10227 void *argp1 = 0 ;
10228 int res1 = 0 ;
10229 int val2 ;
10230 int ecode2 = 0 ;
10231 PyObject * obj0 = 0 ;
10232 PyObject * obj1 = 0 ;
10233 char * kwnames[] = {
10234 (char *) "self",(char *) "n", NULL
10235 };
10236
10237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10239 if (!SWIG_IsOK(res1)) {
10240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10241 }
10242 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10243 ecode2 = SWIG_AsVal_int(obj1, &val2);
10244 if (!SWIG_IsOK(ecode2)) {
10245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10246 }
10247 arg2 = static_cast< int >(val2);
10248 {
10249 PyThreadState* __tstate = wxPyBeginAllowThreads();
10250 (arg1)->SetRow(arg2);
10251 wxPyEndAllowThreads(__tstate);
10252 if (PyErr_Occurred()) SWIG_fail;
10253 }
10254 resultobj = SWIG_Py_Void();
10255 return resultobj;
10256 fail:
10257 return NULL;
10258 }
10259
10260
10261 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10262 PyObject *resultobj = 0;
10263 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10264 int result;
10265 void *argp1 = 0 ;
10266 int res1 = 0 ;
10267 PyObject *swig_obj[1] ;
10268
10269 if (!args) SWIG_fail;
10270 swig_obj[0] = args;
10271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10274 }
10275 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 resultobj = SWIG_From_int(static_cast< int >(result));
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj = 0;
10291 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10292 int arg2 ;
10293 void *argp1 = 0 ;
10294 int res1 = 0 ;
10295 int val2 ;
10296 int ecode2 = 0 ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299 char * kwnames[] = {
10300 (char *) "self",(char *) "n", NULL
10301 };
10302
10303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10307 }
10308 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10309 ecode2 = SWIG_AsVal_int(obj1, &val2);
10310 if (!SWIG_IsOK(ecode2)) {
10311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10312 }
10313 arg2 = static_cast< int >(val2);
10314 {
10315 PyThreadState* __tstate = wxPyBeginAllowThreads();
10316 (arg1)->SetCol(arg2);
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 resultobj = SWIG_Py_Void();
10321 return resultobj;
10322 fail:
10323 return NULL;
10324 }
10325
10326
10327 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10328 PyObject *resultobj = 0;
10329 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10330 int arg2 ;
10331 int arg3 ;
10332 void *argp1 = 0 ;
10333 int res1 = 0 ;
10334 int val2 ;
10335 int ecode2 = 0 ;
10336 int val3 ;
10337 int ecode3 = 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "row",(char *) "col", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10349 }
10350 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10351 ecode2 = SWIG_AsVal_int(obj1, &val2);
10352 if (!SWIG_IsOK(ecode2)) {
10353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10354 }
10355 arg2 = static_cast< int >(val2);
10356 ecode3 = SWIG_AsVal_int(obj2, &val3);
10357 if (!SWIG_IsOK(ecode3)) {
10358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10359 }
10360 arg3 = static_cast< int >(val3);
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 (arg1)->Set(arg2,arg3);
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 resultobj = SWIG_Py_Void();
10368 return resultobj;
10369 fail:
10370 return NULL;
10371 }
10372
10373
10374 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj = 0;
10376 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10377 PyObject *arg2 = (PyObject *) 0 ;
10378 bool result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 char * kwnames[] = {
10384 (char *) "self",(char *) "other", NULL
10385 };
10386
10387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10391 }
10392 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10393 arg2 = obj1;
10394 {
10395 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10396 if (PyErr_Occurred()) SWIG_fail;
10397 }
10398 {
10399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10400 }
10401 return resultobj;
10402 fail:
10403 return NULL;
10404 }
10405
10406
10407 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10408 PyObject *resultobj = 0;
10409 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10410 PyObject *arg2 = (PyObject *) 0 ;
10411 bool result;
10412 void *argp1 = 0 ;
10413 int res1 = 0 ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 char * kwnames[] = {
10417 (char *) "self",(char *) "other", NULL
10418 };
10419
10420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10424 }
10425 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10426 arg2 = obj1;
10427 {
10428 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10441 PyObject *resultobj = 0;
10442 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10443 PyObject *result = 0 ;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 PyObject *swig_obj[1] ;
10447
10448 if (!args) SWIG_fail;
10449 swig_obj[0] = args;
10450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10451 if (!SWIG_IsOK(res1)) {
10452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10453 }
10454 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 result = (PyObject *)wxGridCellCoords_Get(arg1);
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 resultobj = result;
10462 return resultobj;
10463 fail:
10464 return NULL;
10465 }
10466
10467
10468 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 PyObject *obj;
10470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10471 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10472 return SWIG_Py_Void();
10473 }
10474
10475 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10476 return SWIG_Python_InitShadowInstance(args);
10477 }
10478
10479 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj = 0;
10481 wxWindow *arg1 = (wxWindow *) 0 ;
10482 int arg2 = (int) -1 ;
10483 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10484 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10485 wxSize const &arg4_defvalue = wxDefaultSize ;
10486 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10487 long arg5 = (long) wxWANTS_CHARS ;
10488 wxString const &arg6_defvalue = wxPyGridNameStr ;
10489 wxString *arg6 = (wxString *) &arg6_defvalue ;
10490 wxGrid *result = 0 ;
10491 void *argp1 = 0 ;
10492 int res1 = 0 ;
10493 int val2 ;
10494 int ecode2 = 0 ;
10495 wxPoint temp3 ;
10496 wxSize temp4 ;
10497 long val5 ;
10498 int ecode5 = 0 ;
10499 bool temp6 = false ;
10500 PyObject * obj0 = 0 ;
10501 PyObject * obj1 = 0 ;
10502 PyObject * obj2 = 0 ;
10503 PyObject * obj3 = 0 ;
10504 PyObject * obj4 = 0 ;
10505 PyObject * obj5 = 0 ;
10506 char * kwnames[] = {
10507 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10508 };
10509
10510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10512 if (!SWIG_IsOK(res1)) {
10513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10514 }
10515 arg1 = reinterpret_cast< wxWindow * >(argp1);
10516 if (obj1) {
10517 ecode2 = SWIG_AsVal_int(obj1, &val2);
10518 if (!SWIG_IsOK(ecode2)) {
10519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10520 }
10521 arg2 = static_cast< int >(val2);
10522 }
10523 if (obj2) {
10524 {
10525 arg3 = &temp3;
10526 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10527 }
10528 }
10529 if (obj3) {
10530 {
10531 arg4 = &temp4;
10532 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10533 }
10534 }
10535 if (obj4) {
10536 ecode5 = SWIG_AsVal_long(obj4, &val5);
10537 if (!SWIG_IsOK(ecode5)) {
10538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10539 }
10540 arg5 = static_cast< long >(val5);
10541 }
10542 if (obj5) {
10543 {
10544 arg6 = wxString_in_helper(obj5);
10545 if (arg6 == NULL) SWIG_fail;
10546 temp6 = true;
10547 }
10548 }
10549 {
10550 if (!wxPyCheckForApp()) SWIG_fail;
10551 PyThreadState* __tstate = wxPyBeginAllowThreads();
10552 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10553 wxPyEndAllowThreads(__tstate);
10554 if (PyErr_Occurred()) SWIG_fail;
10555 }
10556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10557 {
10558 if (temp6)
10559 delete arg6;
10560 }
10561 return resultobj;
10562 fail:
10563 {
10564 if (temp6)
10565 delete arg6;
10566 }
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10572 PyObject *resultobj = 0;
10573 wxGrid *result = 0 ;
10574
10575 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10576 {
10577 if (!wxPyCheckForApp()) SWIG_fail;
10578 PyThreadState* __tstate = wxPyBeginAllowThreads();
10579 result = (wxGrid *)new wxGrid();
10580 wxPyEndAllowThreads(__tstate);
10581 if (PyErr_Occurred()) SWIG_fail;
10582 }
10583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10584 return resultobj;
10585 fail:
10586 return NULL;
10587 }
10588
10589
10590 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10591 PyObject *resultobj = 0;
10592 wxGrid *arg1 = (wxGrid *) 0 ;
10593 wxWindow *arg2 = (wxWindow *) 0 ;
10594 int arg3 = (int) -1 ;
10595 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10596 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10597 wxSize const &arg5_defvalue = wxDefaultSize ;
10598 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10599 long arg6 = (long) wxWANTS_CHARS ;
10600 wxString const &arg7_defvalue = wxPyGridNameStr ;
10601 wxString *arg7 = (wxString *) &arg7_defvalue ;
10602 bool result;
10603 void *argp1 = 0 ;
10604 int res1 = 0 ;
10605 void *argp2 = 0 ;
10606 int res2 = 0 ;
10607 int val3 ;
10608 int ecode3 = 0 ;
10609 wxPoint temp4 ;
10610 wxSize temp5 ;
10611 long val6 ;
10612 int ecode6 = 0 ;
10613 bool temp7 = false ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 PyObject * obj2 = 0 ;
10617 PyObject * obj3 = 0 ;
10618 PyObject * obj4 = 0 ;
10619 PyObject * obj5 = 0 ;
10620 PyObject * obj6 = 0 ;
10621 char * kwnames[] = {
10622 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10623 };
10624
10625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10627 if (!SWIG_IsOK(res1)) {
10628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10629 }
10630 arg1 = reinterpret_cast< wxGrid * >(argp1);
10631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10632 if (!SWIG_IsOK(res2)) {
10633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10634 }
10635 arg2 = reinterpret_cast< wxWindow * >(argp2);
10636 if (obj2) {
10637 ecode3 = SWIG_AsVal_int(obj2, &val3);
10638 if (!SWIG_IsOK(ecode3)) {
10639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10640 }
10641 arg3 = static_cast< int >(val3);
10642 }
10643 if (obj3) {
10644 {
10645 arg4 = &temp4;
10646 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10647 }
10648 }
10649 if (obj4) {
10650 {
10651 arg5 = &temp5;
10652 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10653 }
10654 }
10655 if (obj5) {
10656 ecode6 = SWIG_AsVal_long(obj5, &val6);
10657 if (!SWIG_IsOK(ecode6)) {
10658 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10659 }
10660 arg6 = static_cast< long >(val6);
10661 }
10662 if (obj6) {
10663 {
10664 arg7 = wxString_in_helper(obj6);
10665 if (arg7 == NULL) SWIG_fail;
10666 temp7 = true;
10667 }
10668 }
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10672 wxPyEndAllowThreads(__tstate);
10673 if (PyErr_Occurred()) SWIG_fail;
10674 }
10675 {
10676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10677 }
10678 {
10679 if (temp7)
10680 delete arg7;
10681 }
10682 return resultobj;
10683 fail:
10684 {
10685 if (temp7)
10686 delete arg7;
10687 }
10688 return NULL;
10689 }
10690
10691
10692 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10693 PyObject *resultobj = 0;
10694 wxGrid *arg1 = (wxGrid *) 0 ;
10695 int arg2 ;
10696 int arg3 ;
10697 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10698 bool result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 int val2 ;
10702 int ecode2 = 0 ;
10703 int val3 ;
10704 int ecode3 = 0 ;
10705 int val4 ;
10706 int ecode4 = 0 ;
10707 PyObject * obj0 = 0 ;
10708 PyObject * obj1 = 0 ;
10709 PyObject * obj2 = 0 ;
10710 PyObject * obj3 = 0 ;
10711 char * kwnames[] = {
10712 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10713 };
10714
10715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10719 }
10720 arg1 = reinterpret_cast< wxGrid * >(argp1);
10721 ecode2 = SWIG_AsVal_int(obj1, &val2);
10722 if (!SWIG_IsOK(ecode2)) {
10723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10724 }
10725 arg2 = static_cast< int >(val2);
10726 ecode3 = SWIG_AsVal_int(obj2, &val3);
10727 if (!SWIG_IsOK(ecode3)) {
10728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10729 }
10730 arg3 = static_cast< int >(val3);
10731 if (obj3) {
10732 ecode4 = SWIG_AsVal_int(obj3, &val4);
10733 if (!SWIG_IsOK(ecode4)) {
10734 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10735 }
10736 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10737 }
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 {
10745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10746 }
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10754 PyObject *resultobj = 0;
10755 wxGrid *arg1 = (wxGrid *) 0 ;
10756 WXGRIDSELECTIONMODES arg2 ;
10757 void *argp1 = 0 ;
10758 int res1 = 0 ;
10759 int val2 ;
10760 int ecode2 = 0 ;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 char * kwnames[] = {
10764 (char *) "self",(char *) "selmode", NULL
10765 };
10766
10767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10769 if (!SWIG_IsOK(res1)) {
10770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10771 }
10772 arg1 = reinterpret_cast< wxGrid * >(argp1);
10773 ecode2 = SWIG_AsVal_int(obj1, &val2);
10774 if (!SWIG_IsOK(ecode2)) {
10775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10776 }
10777 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 (arg1)->SetSelectionMode(arg2);
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_Py_Void();
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10792 PyObject *resultobj = 0;
10793 wxGrid *arg1 = (wxGrid *) 0 ;
10794 WXGRIDSELECTIONMODES result;
10795 void *argp1 = 0 ;
10796 int res1 = 0 ;
10797 PyObject *swig_obj[1] ;
10798
10799 if (!args) SWIG_fail;
10800 swig_obj[0] = args;
10801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10802 if (!SWIG_IsOK(res1)) {
10803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10804 }
10805 arg1 = reinterpret_cast< wxGrid * >(argp1);
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_From_int(static_cast< int >(result));
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10820 PyObject *resultobj = 0;
10821 wxGrid *arg1 = (wxGrid *) 0 ;
10822 int result;
10823 void *argp1 = 0 ;
10824 int res1 = 0 ;
10825 PyObject *swig_obj[1] ;
10826
10827 if (!args) SWIG_fail;
10828 swig_obj[0] = args;
10829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10830 if (!SWIG_IsOK(res1)) {
10831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10832 }
10833 arg1 = reinterpret_cast< wxGrid * >(argp1);
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (int)(arg1)->GetNumberRows();
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_From_int(static_cast< int >(result));
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10848 PyObject *resultobj = 0;
10849 wxGrid *arg1 = (wxGrid *) 0 ;
10850 int result;
10851 void *argp1 = 0 ;
10852 int res1 = 0 ;
10853 PyObject *swig_obj[1] ;
10854
10855 if (!args) SWIG_fail;
10856 swig_obj[0] = args;
10857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10858 if (!SWIG_IsOK(res1)) {
10859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10860 }
10861 arg1 = reinterpret_cast< wxGrid * >(argp1);
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = (int)(arg1)->GetNumberCols();
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_From_int(static_cast< int >(result));
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxGrid *arg1 = (wxGrid *) 0 ;
10878 wxGridTableMessage *arg2 = 0 ;
10879 bool result;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 void *argp2 = 0 ;
10883 int res2 = 0 ;
10884 PyObject * obj0 = 0 ;
10885 PyObject * obj1 = 0 ;
10886 char * kwnames[] = {
10887 (char *) "self",(char *)"arg2", NULL
10888 };
10889
10890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10894 }
10895 arg1 = reinterpret_cast< wxGrid * >(argp1);
10896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10897 if (!SWIG_IsOK(res2)) {
10898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10899 }
10900 if (!argp2) {
10901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10902 }
10903 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10904 {
10905 PyThreadState* __tstate = wxPyBeginAllowThreads();
10906 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10907 wxPyEndAllowThreads(__tstate);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 {
10911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10912 }
10913 return resultobj;
10914 fail:
10915 return NULL;
10916 }
10917
10918
10919 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10920 PyObject *resultobj = 0;
10921 wxGrid *arg1 = (wxGrid *) 0 ;
10922 wxGridTableBase *result = 0 ;
10923 void *argp1 = 0 ;
10924 int res1 = 0 ;
10925 PyObject *swig_obj[1] ;
10926
10927 if (!args) SWIG_fail;
10928 swig_obj[0] = args;
10929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10932 }
10933 arg1 = reinterpret_cast< wxGrid * >(argp1);
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 {
10941 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10942 }
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxGrid *arg1 = (wxGrid *) 0 ;
10952 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10953 bool arg3 = (bool) false ;
10954 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10955 bool result;
10956 void *argp1 = 0 ;
10957 int res1 = 0 ;
10958 int res2 = 0 ;
10959 bool val3 ;
10960 int ecode3 = 0 ;
10961 int val4 ;
10962 int ecode4 = 0 ;
10963 PyObject * obj0 = 0 ;
10964 PyObject * obj1 = 0 ;
10965 PyObject * obj2 = 0 ;
10966 PyObject * obj3 = 0 ;
10967 char * kwnames[] = {
10968 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10969 };
10970
10971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10973 if (!SWIG_IsOK(res1)) {
10974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10975 }
10976 arg1 = reinterpret_cast< wxGrid * >(argp1);
10977 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10978 if (!SWIG_IsOK(res2)) {
10979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10980 }
10981 if (obj2) {
10982 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10983 if (!SWIG_IsOK(ecode3)) {
10984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10985 }
10986 arg3 = static_cast< bool >(val3);
10987 }
10988 if (obj3) {
10989 ecode4 = SWIG_AsVal_int(obj3, &val4);
10990 if (!SWIG_IsOK(ecode4)) {
10991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10992 }
10993 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10994 }
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11003 }
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11011 PyObject *resultobj = 0;
11012 wxGrid *arg1 = (wxGrid *) 0 ;
11013 void *argp1 = 0 ;
11014 int res1 = 0 ;
11015 PyObject *swig_obj[1] ;
11016
11017 if (!args) SWIG_fail;
11018 swig_obj[0] = args;
11019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11020 if (!SWIG_IsOK(res1)) {
11021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11022 }
11023 arg1 = reinterpret_cast< wxGrid * >(argp1);
11024 {
11025 PyThreadState* __tstate = wxPyBeginAllowThreads();
11026 (arg1)->ClearGrid();
11027 wxPyEndAllowThreads(__tstate);
11028 if (PyErr_Occurred()) SWIG_fail;
11029 }
11030 resultobj = SWIG_Py_Void();
11031 return resultobj;
11032 fail:
11033 return NULL;
11034 }
11035
11036
11037 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11038 PyObject *resultobj = 0;
11039 wxGrid *arg1 = (wxGrid *) 0 ;
11040 int arg2 = (int) 0 ;
11041 int arg3 = (int) 1 ;
11042 bool arg4 = (bool) true ;
11043 bool result;
11044 void *argp1 = 0 ;
11045 int res1 = 0 ;
11046 int val2 ;
11047 int ecode2 = 0 ;
11048 int val3 ;
11049 int ecode3 = 0 ;
11050 bool val4 ;
11051 int ecode4 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 PyObject * obj3 = 0 ;
11056 char * kwnames[] = {
11057 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11058 };
11059
11060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11062 if (!SWIG_IsOK(res1)) {
11063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11064 }
11065 arg1 = reinterpret_cast< wxGrid * >(argp1);
11066 if (obj1) {
11067 ecode2 = SWIG_AsVal_int(obj1, &val2);
11068 if (!SWIG_IsOK(ecode2)) {
11069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11070 }
11071 arg2 = static_cast< int >(val2);
11072 }
11073 if (obj2) {
11074 ecode3 = SWIG_AsVal_int(obj2, &val3);
11075 if (!SWIG_IsOK(ecode3)) {
11076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11077 }
11078 arg3 = static_cast< int >(val3);
11079 }
11080 if (obj3) {
11081 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11082 if (!SWIG_IsOK(ecode4)) {
11083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11084 }
11085 arg4 = static_cast< bool >(val4);
11086 }
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11095 }
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj = 0;
11104 wxGrid *arg1 = (wxGrid *) 0 ;
11105 int arg2 = (int) 1 ;
11106 bool arg3 = (bool) true ;
11107 bool result;
11108 void *argp1 = 0 ;
11109 int res1 = 0 ;
11110 int val2 ;
11111 int ecode2 = 0 ;
11112 bool val3 ;
11113 int ecode3 = 0 ;
11114 PyObject * obj0 = 0 ;
11115 PyObject * obj1 = 0 ;
11116 PyObject * obj2 = 0 ;
11117 char * kwnames[] = {
11118 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11119 };
11120
11121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11125 }
11126 arg1 = reinterpret_cast< wxGrid * >(argp1);
11127 if (obj1) {
11128 ecode2 = SWIG_AsVal_int(obj1, &val2);
11129 if (!SWIG_IsOK(ecode2)) {
11130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11131 }
11132 arg2 = static_cast< int >(val2);
11133 }
11134 if (obj2) {
11135 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11136 if (!SWIG_IsOK(ecode3)) {
11137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11138 }
11139 arg3 = static_cast< bool >(val3);
11140 }
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 result = (bool)(arg1)->AppendRows(arg2,arg3);
11144 wxPyEndAllowThreads(__tstate);
11145 if (PyErr_Occurred()) SWIG_fail;
11146 }
11147 {
11148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11149 }
11150 return resultobj;
11151 fail:
11152 return NULL;
11153 }
11154
11155
11156 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj = 0;
11158 wxGrid *arg1 = (wxGrid *) 0 ;
11159 int arg2 = (int) 0 ;
11160 int arg3 = (int) 1 ;
11161 bool arg4 = (bool) true ;
11162 bool result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 int val2 ;
11166 int ecode2 = 0 ;
11167 int val3 ;
11168 int ecode3 = 0 ;
11169 bool val4 ;
11170 int ecode4 = 0 ;
11171 PyObject * obj0 = 0 ;
11172 PyObject * obj1 = 0 ;
11173 PyObject * obj2 = 0 ;
11174 PyObject * obj3 = 0 ;
11175 char * kwnames[] = {
11176 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11177 };
11178
11179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11181 if (!SWIG_IsOK(res1)) {
11182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11183 }
11184 arg1 = reinterpret_cast< wxGrid * >(argp1);
11185 if (obj1) {
11186 ecode2 = SWIG_AsVal_int(obj1, &val2);
11187 if (!SWIG_IsOK(ecode2)) {
11188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11189 }
11190 arg2 = static_cast< int >(val2);
11191 }
11192 if (obj2) {
11193 ecode3 = SWIG_AsVal_int(obj2, &val3);
11194 if (!SWIG_IsOK(ecode3)) {
11195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11196 }
11197 arg3 = static_cast< int >(val3);
11198 }
11199 if (obj3) {
11200 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11201 if (!SWIG_IsOK(ecode4)) {
11202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11203 }
11204 arg4 = static_cast< bool >(val4);
11205 }
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 {
11213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11214 }
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj = 0;
11223 wxGrid *arg1 = (wxGrid *) 0 ;
11224 int arg2 = (int) 0 ;
11225 int arg3 = (int) 1 ;
11226 bool arg4 = (bool) true ;
11227 bool result;
11228 void *argp1 = 0 ;
11229 int res1 = 0 ;
11230 int val2 ;
11231 int ecode2 = 0 ;
11232 int val3 ;
11233 int ecode3 = 0 ;
11234 bool val4 ;
11235 int ecode4 = 0 ;
11236 PyObject * obj0 = 0 ;
11237 PyObject * obj1 = 0 ;
11238 PyObject * obj2 = 0 ;
11239 PyObject * obj3 = 0 ;
11240 char * kwnames[] = {
11241 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11242 };
11243
11244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11246 if (!SWIG_IsOK(res1)) {
11247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11248 }
11249 arg1 = reinterpret_cast< wxGrid * >(argp1);
11250 if (obj1) {
11251 ecode2 = SWIG_AsVal_int(obj1, &val2);
11252 if (!SWIG_IsOK(ecode2)) {
11253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11254 }
11255 arg2 = static_cast< int >(val2);
11256 }
11257 if (obj2) {
11258 ecode3 = SWIG_AsVal_int(obj2, &val3);
11259 if (!SWIG_IsOK(ecode3)) {
11260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11261 }
11262 arg3 = static_cast< int >(val3);
11263 }
11264 if (obj3) {
11265 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11266 if (!SWIG_IsOK(ecode4)) {
11267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11268 }
11269 arg4 = static_cast< bool >(val4);
11270 }
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 {
11278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11279 }
11280 return resultobj;
11281 fail:
11282 return NULL;
11283 }
11284
11285
11286 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj = 0;
11288 wxGrid *arg1 = (wxGrid *) 0 ;
11289 int arg2 = (int) 1 ;
11290 bool arg3 = (bool) true ;
11291 bool result;
11292 void *argp1 = 0 ;
11293 int res1 = 0 ;
11294 int val2 ;
11295 int ecode2 = 0 ;
11296 bool val3 ;
11297 int ecode3 = 0 ;
11298 PyObject * obj0 = 0 ;
11299 PyObject * obj1 = 0 ;
11300 PyObject * obj2 = 0 ;
11301 char * kwnames[] = {
11302 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11303 };
11304
11305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11307 if (!SWIG_IsOK(res1)) {
11308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11309 }
11310 arg1 = reinterpret_cast< wxGrid * >(argp1);
11311 if (obj1) {
11312 ecode2 = SWIG_AsVal_int(obj1, &val2);
11313 if (!SWIG_IsOK(ecode2)) {
11314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11315 }
11316 arg2 = static_cast< int >(val2);
11317 }
11318 if (obj2) {
11319 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11320 if (!SWIG_IsOK(ecode3)) {
11321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11322 }
11323 arg3 = static_cast< bool >(val3);
11324 }
11325 {
11326 PyThreadState* __tstate = wxPyBeginAllowThreads();
11327 result = (bool)(arg1)->AppendCols(arg2,arg3);
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 {
11332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11333 }
11334 return resultobj;
11335 fail:
11336 return NULL;
11337 }
11338
11339
11340 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11341 PyObject *resultobj = 0;
11342 wxGrid *arg1 = (wxGrid *) 0 ;
11343 int arg2 = (int) 0 ;
11344 int arg3 = (int) 1 ;
11345 bool arg4 = (bool) true ;
11346 bool result;
11347 void *argp1 = 0 ;
11348 int res1 = 0 ;
11349 int val2 ;
11350 int ecode2 = 0 ;
11351 int val3 ;
11352 int ecode3 = 0 ;
11353 bool val4 ;
11354 int ecode4 = 0 ;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 PyObject * obj2 = 0 ;
11358 PyObject * obj3 = 0 ;
11359 char * kwnames[] = {
11360 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11361 };
11362
11363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11365 if (!SWIG_IsOK(res1)) {
11366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11367 }
11368 arg1 = reinterpret_cast< wxGrid * >(argp1);
11369 if (obj1) {
11370 ecode2 = SWIG_AsVal_int(obj1, &val2);
11371 if (!SWIG_IsOK(ecode2)) {
11372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11373 }
11374 arg2 = static_cast< int >(val2);
11375 }
11376 if (obj2) {
11377 ecode3 = SWIG_AsVal_int(obj2, &val3);
11378 if (!SWIG_IsOK(ecode3)) {
11379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11380 }
11381 arg3 = static_cast< int >(val3);
11382 }
11383 if (obj3) {
11384 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11385 if (!SWIG_IsOK(ecode4)) {
11386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11387 }
11388 arg4 = static_cast< bool >(val4);
11389 }
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 {
11397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj = 0;
11407 wxGrid *arg1 = (wxGrid *) 0 ;
11408 wxDC *arg2 = 0 ;
11409 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 void *argp2 = 0 ;
11413 int res2 = 0 ;
11414 void *argp3 = 0 ;
11415 int res3 = 0 ;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 PyObject * obj2 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "self",(char *) "dc",(char *) "attr", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11425 if (!SWIG_IsOK(res1)) {
11426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11427 }
11428 arg1 = reinterpret_cast< wxGrid * >(argp1);
11429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11430 if (!SWIG_IsOK(res2)) {
11431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11432 }
11433 if (!argp2) {
11434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11435 }
11436 arg2 = reinterpret_cast< wxDC * >(argp2);
11437 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11438 if (!SWIG_IsOK(res3)) {
11439 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11440 }
11441 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11442 {
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 resultobj = SWIG_Py_Void();
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj = 0;
11457 wxGrid *arg1 = (wxGrid *) 0 ;
11458 wxDC *arg2 = 0 ;
11459 wxString *arg3 = 0 ;
11460 wxRect *arg4 = 0 ;
11461 int arg5 = (int) wxLEFT ;
11462 int arg6 = (int) wxTOP ;
11463 int arg7 = (int) wxHORIZONTAL ;
11464 void *argp1 = 0 ;
11465 int res1 = 0 ;
11466 void *argp2 = 0 ;
11467 int res2 = 0 ;
11468 bool temp3 = false ;
11469 wxRect temp4 ;
11470 int val5 ;
11471 int ecode5 = 0 ;
11472 int val6 ;
11473 int ecode6 = 0 ;
11474 int val7 ;
11475 int ecode7 = 0 ;
11476 PyObject * obj0 = 0 ;
11477 PyObject * obj1 = 0 ;
11478 PyObject * obj2 = 0 ;
11479 PyObject * obj3 = 0 ;
11480 PyObject * obj4 = 0 ;
11481 PyObject * obj5 = 0 ;
11482 PyObject * obj6 = 0 ;
11483 char * kwnames[] = {
11484 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11485 };
11486
11487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11491 }
11492 arg1 = reinterpret_cast< wxGrid * >(argp1);
11493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11494 if (!SWIG_IsOK(res2)) {
11495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11496 }
11497 if (!argp2) {
11498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11499 }
11500 arg2 = reinterpret_cast< wxDC * >(argp2);
11501 {
11502 arg3 = wxString_in_helper(obj2);
11503 if (arg3 == NULL) SWIG_fail;
11504 temp3 = true;
11505 }
11506 {
11507 arg4 = &temp4;
11508 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11509 }
11510 if (obj4) {
11511 ecode5 = SWIG_AsVal_int(obj4, &val5);
11512 if (!SWIG_IsOK(ecode5)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11514 }
11515 arg5 = static_cast< int >(val5);
11516 }
11517 if (obj5) {
11518 ecode6 = SWIG_AsVal_int(obj5, &val6);
11519 if (!SWIG_IsOK(ecode6)) {
11520 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11521 }
11522 arg6 = static_cast< int >(val6);
11523 }
11524 if (obj6) {
11525 ecode7 = SWIG_AsVal_int(obj6, &val7);
11526 if (!SWIG_IsOK(ecode7)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11528 }
11529 arg7 = static_cast< int >(val7);
11530 }
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 resultobj = SWIG_Py_Void();
11538 {
11539 if (temp3)
11540 delete arg3;
11541 }
11542 return resultobj;
11543 fail:
11544 {
11545 if (temp3)
11546 delete arg3;
11547 }
11548 return NULL;
11549 }
11550
11551
11552 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11553 PyObject *resultobj = 0;
11554 wxGrid *arg1 = (wxGrid *) 0 ;
11555 wxDC *arg2 = 0 ;
11556 wxArrayString *arg3 = 0 ;
11557 long *arg4 = (long *) 0 ;
11558 long *arg5 = (long *) 0 ;
11559 void *argp1 = 0 ;
11560 int res1 = 0 ;
11561 void *argp2 = 0 ;
11562 int res2 = 0 ;
11563 bool temp3 = false ;
11564 long temp4 ;
11565 int res4 = SWIG_TMPOBJ ;
11566 long temp5 ;
11567 int res5 = SWIG_TMPOBJ ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 char * kwnames[] = {
11572 (char *) "self",(char *) "dc",(char *) "lines", NULL
11573 };
11574
11575 arg4 = &temp4;
11576 arg5 = &temp5;
11577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11581 }
11582 arg1 = reinterpret_cast< wxGrid * >(argp1);
11583 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11584 if (!SWIG_IsOK(res2)) {
11585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11586 }
11587 if (!argp2) {
11588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11589 }
11590 arg2 = reinterpret_cast< wxDC * >(argp2);
11591 {
11592 if (! PySequence_Check(obj2)) {
11593 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11594 SWIG_fail;
11595 }
11596 arg3 = new wxArrayString;
11597 temp3 = true;
11598 int i, len=PySequence_Length(obj2);
11599 for (i=0; i<len; i++) {
11600 PyObject* item = PySequence_GetItem(obj2, i);
11601 wxString* s = wxString_in_helper(item);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 arg3->Add(*s);
11604 delete s;
11605 Py_DECREF(item);
11606 }
11607 }
11608 {
11609 PyThreadState* __tstate = wxPyBeginAllowThreads();
11610 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 resultobj = SWIG_Py_Void();
11615 if (SWIG_IsTmpObj(res4)) {
11616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11617 } else {
11618 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11620 }
11621 if (SWIG_IsTmpObj(res5)) {
11622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11623 } else {
11624 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11626 }
11627 {
11628 if (temp3) delete arg3;
11629 }
11630 return resultobj;
11631 fail:
11632 {
11633 if (temp3) delete arg3;
11634 }
11635 return NULL;
11636 }
11637
11638
11639 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640 PyObject *resultobj = 0;
11641 wxGrid *arg1 = (wxGrid *) 0 ;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11651 }
11652 arg1 = reinterpret_cast< wxGrid * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 (arg1)->BeginBatch();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 resultobj = SWIG_Py_Void();
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *resultobj = 0;
11668 wxGrid *arg1 = (wxGrid *) 0 ;
11669 void *argp1 = 0 ;
11670 int res1 = 0 ;
11671 PyObject *swig_obj[1] ;
11672
11673 if (!args) SWIG_fail;
11674 swig_obj[0] = args;
11675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11678 }
11679 arg1 = reinterpret_cast< wxGrid * >(argp1);
11680 {
11681 PyThreadState* __tstate = wxPyBeginAllowThreads();
11682 (arg1)->EndBatch();
11683 wxPyEndAllowThreads(__tstate);
11684 if (PyErr_Occurred()) SWIG_fail;
11685 }
11686 resultobj = SWIG_Py_Void();
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 wxGrid *arg1 = (wxGrid *) 0 ;
11696 int result;
11697 void *argp1 = 0 ;
11698 int res1 = 0 ;
11699 PyObject *swig_obj[1] ;
11700
11701 if (!args) SWIG_fail;
11702 swig_obj[0] = args;
11703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11706 }
11707 arg1 = reinterpret_cast< wxGrid * >(argp1);
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (int)(arg1)->GetBatchCount();
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 resultobj = SWIG_From_int(static_cast< int >(result));
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722 PyObject *resultobj = 0;
11723 wxGrid *arg1 = (wxGrid *) 0 ;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 PyObject *swig_obj[1] ;
11727
11728 if (!args) SWIG_fail;
11729 swig_obj[0] = args;
11730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11731 if (!SWIG_IsOK(res1)) {
11732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11733 }
11734 arg1 = reinterpret_cast< wxGrid * >(argp1);
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 (arg1)->ForceRefresh();
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 resultobj = SWIG_Py_Void();
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11749 PyObject *resultobj = 0;
11750 wxGrid *arg1 = (wxGrid *) 0 ;
11751 bool result;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 PyObject *swig_obj[1] ;
11755
11756 if (!args) SWIG_fail;
11757 swig_obj[0] = args;
11758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11759 if (!SWIG_IsOK(res1)) {
11760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11761 }
11762 arg1 = reinterpret_cast< wxGrid * >(argp1);
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (bool)(arg1)->IsEditable();
11766 wxPyEndAllowThreads(__tstate);
11767 if (PyErr_Occurred()) SWIG_fail;
11768 }
11769 {
11770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11771 }
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11779 PyObject *resultobj = 0;
11780 wxGrid *arg1 = (wxGrid *) 0 ;
11781 bool arg2 ;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 bool val2 ;
11785 int ecode2 = 0 ;
11786 PyObject * obj0 = 0 ;
11787 PyObject * obj1 = 0 ;
11788 char * kwnames[] = {
11789 (char *) "self",(char *) "edit", NULL
11790 };
11791
11792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11794 if (!SWIG_IsOK(res1)) {
11795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11796 }
11797 arg1 = reinterpret_cast< wxGrid * >(argp1);
11798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11799 if (!SWIG_IsOK(ecode2)) {
11800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11801 }
11802 arg2 = static_cast< bool >(val2);
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 (arg1)->EnableEditing(arg2);
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 resultobj = SWIG_Py_Void();
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj = 0;
11818 wxGrid *arg1 = (wxGrid *) 0 ;
11819 bool arg2 = (bool) true ;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 bool val2 ;
11823 int ecode2 = 0 ;
11824 PyObject * obj0 = 0 ;
11825 PyObject * obj1 = 0 ;
11826 char * kwnames[] = {
11827 (char *) "self",(char *) "enable", NULL
11828 };
11829
11830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11834 }
11835 arg1 = reinterpret_cast< wxGrid * >(argp1);
11836 if (obj1) {
11837 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11838 if (!SWIG_IsOK(ecode2)) {
11839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11840 }
11841 arg2 = static_cast< bool >(val2);
11842 }
11843 {
11844 PyThreadState* __tstate = wxPyBeginAllowThreads();
11845 (arg1)->EnableCellEditControl(arg2);
11846 wxPyEndAllowThreads(__tstate);
11847 if (PyErr_Occurred()) SWIG_fail;
11848 }
11849 resultobj = SWIG_Py_Void();
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 PyObject *resultobj = 0;
11858 wxGrid *arg1 = (wxGrid *) 0 ;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 if (!args) SWIG_fail;
11864 swig_obj[0] = args;
11865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11868 }
11869 arg1 = reinterpret_cast< wxGrid * >(argp1);
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 (arg1)->DisableCellEditControl();
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 resultobj = SWIG_Py_Void();
11877 return resultobj;
11878 fail:
11879 return NULL;
11880 }
11881
11882
11883 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11884 PyObject *resultobj = 0;
11885 wxGrid *arg1 = (wxGrid *) 0 ;
11886 bool result;
11887 void *argp1 = 0 ;
11888 int res1 = 0 ;
11889 PyObject *swig_obj[1] ;
11890
11891 if (!args) SWIG_fail;
11892 swig_obj[0] = args;
11893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11894 if (!SWIG_IsOK(res1)) {
11895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11896 }
11897 arg1 = reinterpret_cast< wxGrid * >(argp1);
11898 {
11899 PyThreadState* __tstate = wxPyBeginAllowThreads();
11900 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11901 wxPyEndAllowThreads(__tstate);
11902 if (PyErr_Occurred()) SWIG_fail;
11903 }
11904 {
11905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11906 }
11907 return resultobj;
11908 fail:
11909 return NULL;
11910 }
11911
11912
11913 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11914 PyObject *resultobj = 0;
11915 wxGrid *arg1 = (wxGrid *) 0 ;
11916 bool result;
11917 void *argp1 = 0 ;
11918 int res1 = 0 ;
11919 PyObject *swig_obj[1] ;
11920
11921 if (!args) SWIG_fail;
11922 swig_obj[0] = args;
11923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11926 }
11927 arg1 = reinterpret_cast< wxGrid * >(argp1);
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 {
11935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11936 }
11937 return resultobj;
11938 fail:
11939 return NULL;
11940 }
11941
11942
11943 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11944 PyObject *resultobj = 0;
11945 wxGrid *arg1 = (wxGrid *) 0 ;
11946 bool result;
11947 void *argp1 = 0 ;
11948 int res1 = 0 ;
11949 PyObject *swig_obj[1] ;
11950
11951 if (!args) SWIG_fail;
11952 swig_obj[0] = args;
11953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11956 }
11957 arg1 = reinterpret_cast< wxGrid * >(argp1);
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 {
11965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11966 }
11967 return resultobj;
11968 fail:
11969 return NULL;
11970 }
11971
11972
11973 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11974 PyObject *resultobj = 0;
11975 wxGrid *arg1 = (wxGrid *) 0 ;
11976 bool result;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 PyObject *swig_obj[1] ;
11980
11981 if (!args) SWIG_fail;
11982 swig_obj[0] = args;
11983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11984 if (!SWIG_IsOK(res1)) {
11985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11986 }
11987 arg1 = reinterpret_cast< wxGrid * >(argp1);
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12004 PyObject *resultobj = 0;
12005 wxGrid *arg1 = (wxGrid *) 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 PyObject *swig_obj[1] ;
12009
12010 if (!args) SWIG_fail;
12011 swig_obj[0] = args;
12012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12013 if (!SWIG_IsOK(res1)) {
12014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12015 }
12016 arg1 = reinterpret_cast< wxGrid * >(argp1);
12017 {
12018 PyThreadState* __tstate = wxPyBeginAllowThreads();
12019 (arg1)->ShowCellEditControl();
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 resultobj = SWIG_Py_Void();
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12031 PyObject *resultobj = 0;
12032 wxGrid *arg1 = (wxGrid *) 0 ;
12033 void *argp1 = 0 ;
12034 int res1 = 0 ;
12035 PyObject *swig_obj[1] ;
12036
12037 if (!args) SWIG_fail;
12038 swig_obj[0] = args;
12039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12040 if (!SWIG_IsOK(res1)) {
12041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12042 }
12043 arg1 = reinterpret_cast< wxGrid * >(argp1);
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 (arg1)->HideCellEditControl();
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_Py_Void();
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12058 PyObject *resultobj = 0;
12059 wxGrid *arg1 = (wxGrid *) 0 ;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12069 }
12070 arg1 = reinterpret_cast< wxGrid * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 (arg1)->SaveEditControlValue();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_Py_Void();
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12085 PyObject *resultobj = 0;
12086 wxGrid *arg1 = (wxGrid *) 0 ;
12087 int arg2 ;
12088 int arg3 ;
12089 wxGridCellCoords result;
12090 void *argp1 = 0 ;
12091 int res1 = 0 ;
12092 int val2 ;
12093 int ecode2 = 0 ;
12094 int val3 ;
12095 int ecode3 = 0 ;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 PyObject * obj2 = 0 ;
12099 char * kwnames[] = {
12100 (char *) "self",(char *) "x",(char *) "y", NULL
12101 };
12102
12103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12105 if (!SWIG_IsOK(res1)) {
12106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12107 }
12108 arg1 = reinterpret_cast< wxGrid * >(argp1);
12109 ecode2 = SWIG_AsVal_int(obj1, &val2);
12110 if (!SWIG_IsOK(ecode2)) {
12111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12112 }
12113 arg2 = static_cast< int >(val2);
12114 ecode3 = SWIG_AsVal_int(obj2, &val3);
12115 if (!SWIG_IsOK(ecode3)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12117 }
12118 arg3 = static_cast< int >(val3);
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = wxGrid_XYToCell(arg1,arg2,arg3);
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12126 return resultobj;
12127 fail:
12128 return NULL;
12129 }
12130
12131
12132 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12133 PyObject *resultobj = 0;
12134 wxGrid *arg1 = (wxGrid *) 0 ;
12135 int arg2 ;
12136 int result;
12137 void *argp1 = 0 ;
12138 int res1 = 0 ;
12139 int val2 ;
12140 int ecode2 = 0 ;
12141 PyObject * obj0 = 0 ;
12142 PyObject * obj1 = 0 ;
12143 char * kwnames[] = {
12144 (char *) "self",(char *) "y", NULL
12145 };
12146
12147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12149 if (!SWIG_IsOK(res1)) {
12150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12151 }
12152 arg1 = reinterpret_cast< wxGrid * >(argp1);
12153 ecode2 = SWIG_AsVal_int(obj1, &val2);
12154 if (!SWIG_IsOK(ecode2)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12156 }
12157 arg2 = static_cast< int >(val2);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (int)(arg1)->YToRow(arg2);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_From_int(static_cast< int >(result));
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj = 0;
12173 wxGrid *arg1 = (wxGrid *) 0 ;
12174 int arg2 ;
12175 bool arg3 = (bool) false ;
12176 int result;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 int val2 ;
12180 int ecode2 = 0 ;
12181 bool val3 ;
12182 int ecode3 = 0 ;
12183 PyObject * obj0 = 0 ;
12184 PyObject * obj1 = 0 ;
12185 PyObject * obj2 = 0 ;
12186 char * kwnames[] = {
12187 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12188 };
12189
12190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12192 if (!SWIG_IsOK(res1)) {
12193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12194 }
12195 arg1 = reinterpret_cast< wxGrid * >(argp1);
12196 ecode2 = SWIG_AsVal_int(obj1, &val2);
12197 if (!SWIG_IsOK(ecode2)) {
12198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12199 }
12200 arg2 = static_cast< int >(val2);
12201 if (obj2) {
12202 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12203 if (!SWIG_IsOK(ecode3)) {
12204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12205 }
12206 arg3 = static_cast< bool >(val3);
12207 }
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 result = (int)(arg1)->XToCol(arg2,arg3);
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 resultobj = SWIG_From_int(static_cast< int >(result));
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj = 0;
12223 wxGrid *arg1 = (wxGrid *) 0 ;
12224 int arg2 ;
12225 int result;
12226 void *argp1 = 0 ;
12227 int res1 = 0 ;
12228 int val2 ;
12229 int ecode2 = 0 ;
12230 PyObject * obj0 = 0 ;
12231 PyObject * obj1 = 0 ;
12232 char * kwnames[] = {
12233 (char *) "self",(char *) "y", NULL
12234 };
12235
12236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12238 if (!SWIG_IsOK(res1)) {
12239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12240 }
12241 arg1 = reinterpret_cast< wxGrid * >(argp1);
12242 ecode2 = SWIG_AsVal_int(obj1, &val2);
12243 if (!SWIG_IsOK(ecode2)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12245 }
12246 arg2 = static_cast< int >(val2);
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (int)(arg1)->YToEdgeOfRow(arg2);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 resultobj = SWIG_From_int(static_cast< int >(result));
12254 return resultobj;
12255 fail:
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12261 PyObject *resultobj = 0;
12262 wxGrid *arg1 = (wxGrid *) 0 ;
12263 int arg2 ;
12264 int result;
12265 void *argp1 = 0 ;
12266 int res1 = 0 ;
12267 int val2 ;
12268 int ecode2 = 0 ;
12269 PyObject * obj0 = 0 ;
12270 PyObject * obj1 = 0 ;
12271 char * kwnames[] = {
12272 (char *) "self",(char *) "x", NULL
12273 };
12274
12275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12277 if (!SWIG_IsOK(res1)) {
12278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12279 }
12280 arg1 = reinterpret_cast< wxGrid * >(argp1);
12281 ecode2 = SWIG_AsVal_int(obj1, &val2);
12282 if (!SWIG_IsOK(ecode2)) {
12283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12284 }
12285 arg2 = static_cast< int >(val2);
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = (int)(arg1)->XToEdgeOfCol(arg2);
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 resultobj = SWIG_From_int(static_cast< int >(result));
12293 return resultobj;
12294 fail:
12295 return NULL;
12296 }
12297
12298
12299 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj = 0;
12301 wxGrid *arg1 = (wxGrid *) 0 ;
12302 int arg2 ;
12303 int arg3 ;
12304 wxRect result;
12305 void *argp1 = 0 ;
12306 int res1 = 0 ;
12307 int val2 ;
12308 int ecode2 = 0 ;
12309 int val3 ;
12310 int ecode3 = 0 ;
12311 PyObject * obj0 = 0 ;
12312 PyObject * obj1 = 0 ;
12313 PyObject * obj2 = 0 ;
12314 char * kwnames[] = {
12315 (char *) "self",(char *) "row",(char *) "col", NULL
12316 };
12317
12318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12320 if (!SWIG_IsOK(res1)) {
12321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12322 }
12323 arg1 = reinterpret_cast< wxGrid * >(argp1);
12324 ecode2 = SWIG_AsVal_int(obj1, &val2);
12325 if (!SWIG_IsOK(ecode2)) {
12326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12327 }
12328 arg2 = static_cast< int >(val2);
12329 ecode3 = SWIG_AsVal_int(obj2, &val3);
12330 if (!SWIG_IsOK(ecode3)) {
12331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12332 }
12333 arg3 = static_cast< int >(val3);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (arg1)->CellToRect(arg2,arg3);
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12348 PyObject *resultobj = 0;
12349 wxGrid *arg1 = (wxGrid *) 0 ;
12350 int result;
12351 void *argp1 = 0 ;
12352 int res1 = 0 ;
12353 PyObject *swig_obj[1] ;
12354
12355 if (!args) SWIG_fail;
12356 swig_obj[0] = args;
12357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12358 if (!SWIG_IsOK(res1)) {
12359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12360 }
12361 arg1 = reinterpret_cast< wxGrid * >(argp1);
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 result = (int)(arg1)->GetGridCursorRow();
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 resultobj = SWIG_From_int(static_cast< int >(result));
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12376 PyObject *resultobj = 0;
12377 wxGrid *arg1 = (wxGrid *) 0 ;
12378 int result;
12379 void *argp1 = 0 ;
12380 int res1 = 0 ;
12381 PyObject *swig_obj[1] ;
12382
12383 if (!args) SWIG_fail;
12384 swig_obj[0] = args;
12385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12386 if (!SWIG_IsOK(res1)) {
12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12388 }
12389 arg1 = reinterpret_cast< wxGrid * >(argp1);
12390 {
12391 PyThreadState* __tstate = wxPyBeginAllowThreads();
12392 result = (int)(arg1)->GetGridCursorCol();
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 resultobj = SWIG_From_int(static_cast< int >(result));
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj = 0;
12405 wxGrid *arg1 = (wxGrid *) 0 ;
12406 int arg2 ;
12407 int arg3 ;
12408 bool arg4 = (bool) true ;
12409 bool result;
12410 void *argp1 = 0 ;
12411 int res1 = 0 ;
12412 int val2 ;
12413 int ecode2 = 0 ;
12414 int val3 ;
12415 int ecode3 = 0 ;
12416 bool val4 ;
12417 int ecode4 = 0 ;
12418 PyObject * obj0 = 0 ;
12419 PyObject * obj1 = 0 ;
12420 PyObject * obj2 = 0 ;
12421 PyObject * obj3 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12428 if (!SWIG_IsOK(res1)) {
12429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12430 }
12431 arg1 = reinterpret_cast< wxGrid * >(argp1);
12432 ecode2 = SWIG_AsVal_int(obj1, &val2);
12433 if (!SWIG_IsOK(ecode2)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12435 }
12436 arg2 = static_cast< int >(val2);
12437 ecode3 = SWIG_AsVal_int(obj2, &val3);
12438 if (!SWIG_IsOK(ecode3)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12440 }
12441 arg3 = static_cast< int >(val3);
12442 if (obj3) {
12443 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12444 if (!SWIG_IsOK(ecode4)) {
12445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12446 }
12447 arg4 = static_cast< bool >(val4);
12448 }
12449 {
12450 PyThreadState* __tstate = wxPyBeginAllowThreads();
12451 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 {
12456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj = 0;
12466 wxGrid *arg1 = (wxGrid *) 0 ;
12467 int arg2 ;
12468 int arg3 ;
12469 void *argp1 = 0 ;
12470 int res1 = 0 ;
12471 int val2 ;
12472 int ecode2 = 0 ;
12473 int val3 ;
12474 int ecode3 = 0 ;
12475 PyObject * obj0 = 0 ;
12476 PyObject * obj1 = 0 ;
12477 PyObject * obj2 = 0 ;
12478 char * kwnames[] = {
12479 (char *) "self",(char *) "row",(char *) "col", NULL
12480 };
12481
12482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12484 if (!SWIG_IsOK(res1)) {
12485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12486 }
12487 arg1 = reinterpret_cast< wxGrid * >(argp1);
12488 ecode2 = SWIG_AsVal_int(obj1, &val2);
12489 if (!SWIG_IsOK(ecode2)) {
12490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12491 }
12492 arg2 = static_cast< int >(val2);
12493 ecode3 = SWIG_AsVal_int(obj2, &val3);
12494 if (!SWIG_IsOK(ecode3)) {
12495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12496 }
12497 arg3 = static_cast< int >(val3);
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 (arg1)->MakeCellVisible(arg2,arg3);
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 resultobj = SWIG_Py_Void();
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj = 0;
12513 wxGrid *arg1 = (wxGrid *) 0 ;
12514 int arg2 ;
12515 int arg3 ;
12516 void *argp1 = 0 ;
12517 int res1 = 0 ;
12518 int val2 ;
12519 int ecode2 = 0 ;
12520 int val3 ;
12521 int ecode3 = 0 ;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12524 PyObject * obj2 = 0 ;
12525 char * kwnames[] = {
12526 (char *) "self",(char *) "row",(char *) "col", NULL
12527 };
12528
12529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12531 if (!SWIG_IsOK(res1)) {
12532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12533 }
12534 arg1 = reinterpret_cast< wxGrid * >(argp1);
12535 ecode2 = SWIG_AsVal_int(obj1, &val2);
12536 if (!SWIG_IsOK(ecode2)) {
12537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12538 }
12539 arg2 = static_cast< int >(val2);
12540 ecode3 = SWIG_AsVal_int(obj2, &val3);
12541 if (!SWIG_IsOK(ecode3)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12543 }
12544 arg3 = static_cast< int >(val3);
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 (arg1)->SetGridCursor(arg2,arg3);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 resultobj = SWIG_Py_Void();
12552 return resultobj;
12553 fail:
12554 return NULL;
12555 }
12556
12557
12558 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12559 PyObject *resultobj = 0;
12560 wxGrid *arg1 = (wxGrid *) 0 ;
12561 bool arg2 ;
12562 bool result;
12563 void *argp1 = 0 ;
12564 int res1 = 0 ;
12565 bool val2 ;
12566 int ecode2 = 0 ;
12567 PyObject * obj0 = 0 ;
12568 PyObject * obj1 = 0 ;
12569 char * kwnames[] = {
12570 (char *) "self",(char *) "expandSelection", NULL
12571 };
12572
12573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12575 if (!SWIG_IsOK(res1)) {
12576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12577 }
12578 arg1 = reinterpret_cast< wxGrid * >(argp1);
12579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12580 if (!SWIG_IsOK(ecode2)) {
12581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12582 }
12583 arg2 = static_cast< bool >(val2);
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (bool)(arg1)->MoveCursorUp(arg2);
12587 wxPyEndAllowThreads(__tstate);
12588 if (PyErr_Occurred()) SWIG_fail;
12589 }
12590 {
12591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12592 }
12593 return resultobj;
12594 fail:
12595 return NULL;
12596 }
12597
12598
12599 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12600 PyObject *resultobj = 0;
12601 wxGrid *arg1 = (wxGrid *) 0 ;
12602 bool arg2 ;
12603 bool result;
12604 void *argp1 = 0 ;
12605 int res1 = 0 ;
12606 bool val2 ;
12607 int ecode2 = 0 ;
12608 PyObject * obj0 = 0 ;
12609 PyObject * obj1 = 0 ;
12610 char * kwnames[] = {
12611 (char *) "self",(char *) "expandSelection", NULL
12612 };
12613
12614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12616 if (!SWIG_IsOK(res1)) {
12617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12618 }
12619 arg1 = reinterpret_cast< wxGrid * >(argp1);
12620 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12621 if (!SWIG_IsOK(ecode2)) {
12622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12623 }
12624 arg2 = static_cast< bool >(val2);
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (bool)(arg1)->MoveCursorDown(arg2);
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 {
12632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12633 }
12634 return resultobj;
12635 fail:
12636 return NULL;
12637 }
12638
12639
12640 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12641 PyObject *resultobj = 0;
12642 wxGrid *arg1 = (wxGrid *) 0 ;
12643 bool arg2 ;
12644 bool result;
12645 void *argp1 = 0 ;
12646 int res1 = 0 ;
12647 bool val2 ;
12648 int ecode2 = 0 ;
12649 PyObject * obj0 = 0 ;
12650 PyObject * obj1 = 0 ;
12651 char * kwnames[] = {
12652 (char *) "self",(char *) "expandSelection", NULL
12653 };
12654
12655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12657 if (!SWIG_IsOK(res1)) {
12658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12659 }
12660 arg1 = reinterpret_cast< wxGrid * >(argp1);
12661 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12662 if (!SWIG_IsOK(ecode2)) {
12663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12664 }
12665 arg2 = static_cast< bool >(val2);
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 result = (bool)(arg1)->MoveCursorLeft(arg2);
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 {
12673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12674 }
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12682 PyObject *resultobj = 0;
12683 wxGrid *arg1 = (wxGrid *) 0 ;
12684 bool arg2 ;
12685 bool result;
12686 void *argp1 = 0 ;
12687 int res1 = 0 ;
12688 bool val2 ;
12689 int ecode2 = 0 ;
12690 PyObject * obj0 = 0 ;
12691 PyObject * obj1 = 0 ;
12692 char * kwnames[] = {
12693 (char *) "self",(char *) "expandSelection", NULL
12694 };
12695
12696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12698 if (!SWIG_IsOK(res1)) {
12699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12700 }
12701 arg1 = reinterpret_cast< wxGrid * >(argp1);
12702 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12703 if (!SWIG_IsOK(ecode2)) {
12704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12705 }
12706 arg2 = static_cast< bool >(val2);
12707 {
12708 PyThreadState* __tstate = wxPyBeginAllowThreads();
12709 result = (bool)(arg1)->MoveCursorRight(arg2);
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723 PyObject *resultobj = 0;
12724 wxGrid *arg1 = (wxGrid *) 0 ;
12725 bool result;
12726 void *argp1 = 0 ;
12727 int res1 = 0 ;
12728 PyObject *swig_obj[1] ;
12729
12730 if (!args) SWIG_fail;
12731 swig_obj[0] = args;
12732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12735 }
12736 arg1 = reinterpret_cast< wxGrid * >(argp1);
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (bool)(arg1)->MovePageDown();
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 wxGrid *arg1 = (wxGrid *) 0 ;
12755 bool result;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 PyObject *swig_obj[1] ;
12759
12760 if (!args) SWIG_fail;
12761 swig_obj[0] = args;
12762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12763 if (!SWIG_IsOK(res1)) {
12764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12765 }
12766 arg1 = reinterpret_cast< wxGrid * >(argp1);
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (bool)(arg1)->MovePageUp();
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 {
12774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12775 }
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12783 PyObject *resultobj = 0;
12784 wxGrid *arg1 = (wxGrid *) 0 ;
12785 bool arg2 ;
12786 bool result;
12787 void *argp1 = 0 ;
12788 int res1 = 0 ;
12789 bool val2 ;
12790 int ecode2 = 0 ;
12791 PyObject * obj0 = 0 ;
12792 PyObject * obj1 = 0 ;
12793 char * kwnames[] = {
12794 (char *) "self",(char *) "expandSelection", NULL
12795 };
12796
12797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12799 if (!SWIG_IsOK(res1)) {
12800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12801 }
12802 arg1 = reinterpret_cast< wxGrid * >(argp1);
12803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12804 if (!SWIG_IsOK(ecode2)) {
12805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12806 }
12807 arg2 = static_cast< bool >(val2);
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 {
12815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12816 }
12817 return resultobj;
12818 fail:
12819 return NULL;
12820 }
12821
12822
12823 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12824 PyObject *resultobj = 0;
12825 wxGrid *arg1 = (wxGrid *) 0 ;
12826 bool arg2 ;
12827 bool result;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 bool val2 ;
12831 int ecode2 = 0 ;
12832 PyObject * obj0 = 0 ;
12833 PyObject * obj1 = 0 ;
12834 char * kwnames[] = {
12835 (char *) "self",(char *) "expandSelection", NULL
12836 };
12837
12838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12840 if (!SWIG_IsOK(res1)) {
12841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12842 }
12843 arg1 = reinterpret_cast< wxGrid * >(argp1);
12844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12845 if (!SWIG_IsOK(ecode2)) {
12846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12847 }
12848 arg2 = static_cast< bool >(val2);
12849 {
12850 PyThreadState* __tstate = wxPyBeginAllowThreads();
12851 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12852 wxPyEndAllowThreads(__tstate);
12853 if (PyErr_Occurred()) SWIG_fail;
12854 }
12855 {
12856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12857 }
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj = 0;
12866 wxGrid *arg1 = (wxGrid *) 0 ;
12867 bool arg2 ;
12868 bool result;
12869 void *argp1 = 0 ;
12870 int res1 = 0 ;
12871 bool val2 ;
12872 int ecode2 = 0 ;
12873 PyObject * obj0 = 0 ;
12874 PyObject * obj1 = 0 ;
12875 char * kwnames[] = {
12876 (char *) "self",(char *) "expandSelection", NULL
12877 };
12878
12879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12881 if (!SWIG_IsOK(res1)) {
12882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12883 }
12884 arg1 = reinterpret_cast< wxGrid * >(argp1);
12885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12886 if (!SWIG_IsOK(ecode2)) {
12887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12888 }
12889 arg2 = static_cast< bool >(val2);
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 {
12897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12898 }
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12906 PyObject *resultobj = 0;
12907 wxGrid *arg1 = (wxGrid *) 0 ;
12908 bool arg2 ;
12909 bool result;
12910 void *argp1 = 0 ;
12911 int res1 = 0 ;
12912 bool val2 ;
12913 int ecode2 = 0 ;
12914 PyObject * obj0 = 0 ;
12915 PyObject * obj1 = 0 ;
12916 char * kwnames[] = {
12917 (char *) "self",(char *) "expandSelection", NULL
12918 };
12919
12920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12922 if (!SWIG_IsOK(res1)) {
12923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12924 }
12925 arg1 = reinterpret_cast< wxGrid * >(argp1);
12926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12927 if (!SWIG_IsOK(ecode2)) {
12928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12929 }
12930 arg2 = static_cast< bool >(val2);
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 {
12938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12939 }
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12947 PyObject *resultobj = 0;
12948 wxGrid *arg1 = (wxGrid *) 0 ;
12949 int result;
12950 void *argp1 = 0 ;
12951 int res1 = 0 ;
12952 PyObject *swig_obj[1] ;
12953
12954 if (!args) SWIG_fail;
12955 swig_obj[0] = args;
12956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12957 if (!SWIG_IsOK(res1)) {
12958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12959 }
12960 arg1 = reinterpret_cast< wxGrid * >(argp1);
12961 {
12962 PyThreadState* __tstate = wxPyBeginAllowThreads();
12963 result = (int)(arg1)->GetDefaultRowLabelSize();
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 resultobj = SWIG_From_int(static_cast< int >(result));
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12975 PyObject *resultobj = 0;
12976 wxGrid *arg1 = (wxGrid *) 0 ;
12977 int result;
12978 void *argp1 = 0 ;
12979 int res1 = 0 ;
12980 PyObject *swig_obj[1] ;
12981
12982 if (!args) SWIG_fail;
12983 swig_obj[0] = args;
12984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12985 if (!SWIG_IsOK(res1)) {
12986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12987 }
12988 arg1 = reinterpret_cast< wxGrid * >(argp1);
12989 {
12990 PyThreadState* __tstate = wxPyBeginAllowThreads();
12991 result = (int)(arg1)->GetRowLabelSize();
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 resultobj = SWIG_From_int(static_cast< int >(result));
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13003 PyObject *resultobj = 0;
13004 wxGrid *arg1 = (wxGrid *) 0 ;
13005 int result;
13006 void *argp1 = 0 ;
13007 int res1 = 0 ;
13008 PyObject *swig_obj[1] ;
13009
13010 if (!args) SWIG_fail;
13011 swig_obj[0] = args;
13012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13013 if (!SWIG_IsOK(res1)) {
13014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13015 }
13016 arg1 = reinterpret_cast< wxGrid * >(argp1);
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (int)(arg1)->GetDefaultColLabelSize();
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_From_int(static_cast< int >(result));
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxGrid *arg1 = (wxGrid *) 0 ;
13033 int result;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 PyObject *swig_obj[1] ;
13037
13038 if (!args) SWIG_fail;
13039 swig_obj[0] = args;
13040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13041 if (!SWIG_IsOK(res1)) {
13042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13043 }
13044 arg1 = reinterpret_cast< wxGrid * >(argp1);
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (int)(arg1)->GetColLabelSize();
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_From_int(static_cast< int >(result));
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13059 PyObject *resultobj = 0;
13060 wxGrid *arg1 = (wxGrid *) 0 ;
13061 wxColour result;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 PyObject *swig_obj[1] ;
13065
13066 if (!args) SWIG_fail;
13067 swig_obj[0] = args;
13068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13069 if (!SWIG_IsOK(res1)) {
13070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13071 }
13072 arg1 = reinterpret_cast< wxGrid * >(argp1);
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (arg1)->GetLabelBackgroundColour();
13076 wxPyEndAllowThreads(__tstate);
13077 if (PyErr_Occurred()) SWIG_fail;
13078 }
13079 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13080 return resultobj;
13081 fail:
13082 return NULL;
13083 }
13084
13085
13086 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13087 PyObject *resultobj = 0;
13088 wxGrid *arg1 = (wxGrid *) 0 ;
13089 wxColour result;
13090 void *argp1 = 0 ;
13091 int res1 = 0 ;
13092 PyObject *swig_obj[1] ;
13093
13094 if (!args) SWIG_fail;
13095 swig_obj[0] = args;
13096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13097 if (!SWIG_IsOK(res1)) {
13098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13099 }
13100 arg1 = reinterpret_cast< wxGrid * >(argp1);
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (arg1)->GetLabelTextColour();
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxGrid *arg1 = (wxGrid *) 0 ;
13117 wxFont result;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13127 }
13128 arg1 = reinterpret_cast< wxGrid * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (arg1)->GetLabelFont();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13136 return resultobj;
13137 fail:
13138 return NULL;
13139 }
13140
13141
13142 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13143 PyObject *resultobj = 0;
13144 wxGrid *arg1 = (wxGrid *) 0 ;
13145 int *arg2 = (int *) 0 ;
13146 int *arg3 = (int *) 0 ;
13147 void *argp1 = 0 ;
13148 int res1 = 0 ;
13149 int temp2 ;
13150 int res2 = SWIG_TMPOBJ ;
13151 int temp3 ;
13152 int res3 = SWIG_TMPOBJ ;
13153 PyObject *swig_obj[1] ;
13154
13155 arg2 = &temp2;
13156 arg3 = &temp3;
13157 if (!args) SWIG_fail;
13158 swig_obj[0] = args;
13159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13162 }
13163 arg1 = reinterpret_cast< wxGrid * >(argp1);
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 (arg1)->GetRowLabelAlignment(arg2,arg3);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_Py_Void();
13171 if (SWIG_IsTmpObj(res2)) {
13172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13173 } else {
13174 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13176 }
13177 if (SWIG_IsTmpObj(res3)) {
13178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13179 } else {
13180 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13182 }
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13190 PyObject *resultobj = 0;
13191 wxGrid *arg1 = (wxGrid *) 0 ;
13192 int *arg2 = (int *) 0 ;
13193 int *arg3 = (int *) 0 ;
13194 void *argp1 = 0 ;
13195 int res1 = 0 ;
13196 int temp2 ;
13197 int res2 = SWIG_TMPOBJ ;
13198 int temp3 ;
13199 int res3 = SWIG_TMPOBJ ;
13200 PyObject *swig_obj[1] ;
13201
13202 arg2 = &temp2;
13203 arg3 = &temp3;
13204 if (!args) SWIG_fail;
13205 swig_obj[0] = args;
13206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13207 if (!SWIG_IsOK(res1)) {
13208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13209 }
13210 arg1 = reinterpret_cast< wxGrid * >(argp1);
13211 {
13212 PyThreadState* __tstate = wxPyBeginAllowThreads();
13213 (arg1)->GetColLabelAlignment(arg2,arg3);
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 resultobj = SWIG_Py_Void();
13218 if (SWIG_IsTmpObj(res2)) {
13219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13220 } else {
13221 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13223 }
13224 if (SWIG_IsTmpObj(res3)) {
13225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13226 } else {
13227 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13229 }
13230 return resultobj;
13231 fail:
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13237 PyObject *resultobj = 0;
13238 wxGrid *arg1 = (wxGrid *) 0 ;
13239 int result;
13240 void *argp1 = 0 ;
13241 int res1 = 0 ;
13242 PyObject *swig_obj[1] ;
13243
13244 if (!args) SWIG_fail;
13245 swig_obj[0] = args;
13246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13247 if (!SWIG_IsOK(res1)) {
13248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13249 }
13250 arg1 = reinterpret_cast< wxGrid * >(argp1);
13251 {
13252 PyThreadState* __tstate = wxPyBeginAllowThreads();
13253 result = (int)(arg1)->GetColLabelTextOrientation();
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 resultobj = SWIG_From_int(static_cast< int >(result));
13258 return resultobj;
13259 fail:
13260 return NULL;
13261 }
13262
13263
13264 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13265 PyObject *resultobj = 0;
13266 wxGrid *arg1 = (wxGrid *) 0 ;
13267 int arg2 ;
13268 wxString result;
13269 void *argp1 = 0 ;
13270 int res1 = 0 ;
13271 int val2 ;
13272 int ecode2 = 0 ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 char * kwnames[] = {
13276 (char *) "self",(char *) "row", NULL
13277 };
13278
13279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13281 if (!SWIG_IsOK(res1)) {
13282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13283 }
13284 arg1 = reinterpret_cast< wxGrid * >(argp1);
13285 ecode2 = SWIG_AsVal_int(obj1, &val2);
13286 if (!SWIG_IsOK(ecode2)) {
13287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13288 }
13289 arg2 = static_cast< int >(val2);
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 result = (arg1)->GetRowLabelValue(arg2);
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 {
13297 #if wxUSE_UNICODE
13298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13299 #else
13300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13301 #endif
13302 }
13303 return resultobj;
13304 fail:
13305 return NULL;
13306 }
13307
13308
13309 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13310 PyObject *resultobj = 0;
13311 wxGrid *arg1 = (wxGrid *) 0 ;
13312 int arg2 ;
13313 wxString result;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 int val2 ;
13317 int ecode2 = 0 ;
13318 PyObject * obj0 = 0 ;
13319 PyObject * obj1 = 0 ;
13320 char * kwnames[] = {
13321 (char *) "self",(char *) "col", NULL
13322 };
13323
13324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13326 if (!SWIG_IsOK(res1)) {
13327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13328 }
13329 arg1 = reinterpret_cast< wxGrid * >(argp1);
13330 ecode2 = SWIG_AsVal_int(obj1, &val2);
13331 if (!SWIG_IsOK(ecode2)) {
13332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13333 }
13334 arg2 = static_cast< int >(val2);
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = (arg1)->GetColLabelValue(arg2);
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 {
13342 #if wxUSE_UNICODE
13343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13344 #else
13345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13346 #endif
13347 }
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13355 PyObject *resultobj = 0;
13356 wxGrid *arg1 = (wxGrid *) 0 ;
13357 wxColour result;
13358 void *argp1 = 0 ;
13359 int res1 = 0 ;
13360 PyObject *swig_obj[1] ;
13361
13362 if (!args) SWIG_fail;
13363 swig_obj[0] = args;
13364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13367 }
13368 arg1 = reinterpret_cast< wxGrid * >(argp1);
13369 {
13370 PyThreadState* __tstate = wxPyBeginAllowThreads();
13371 result = (arg1)->GetGridLineColour();
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13376 return resultobj;
13377 fail:
13378 return NULL;
13379 }
13380
13381
13382 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13383 PyObject *resultobj = 0;
13384 wxGrid *arg1 = (wxGrid *) 0 ;
13385 wxPen result;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13395 }
13396 arg1 = reinterpret_cast< wxGrid * >(argp1);
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (arg1)->GetDefaultGridLinePen();
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxGrid *arg1 = (wxGrid *) 0 ;
13413 int arg2 ;
13414 wxPen result;
13415 void *argp1 = 0 ;
13416 int res1 = 0 ;
13417 int val2 ;
13418 int ecode2 = 0 ;
13419 PyObject * obj0 = 0 ;
13420 PyObject * obj1 = 0 ;
13421 char * kwnames[] = {
13422 (char *) "self",(char *) "row", NULL
13423 };
13424
13425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13427 if (!SWIG_IsOK(res1)) {
13428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13429 }
13430 arg1 = reinterpret_cast< wxGrid * >(argp1);
13431 ecode2 = SWIG_AsVal_int(obj1, &val2);
13432 if (!SWIG_IsOK(ecode2)) {
13433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13434 }
13435 arg2 = static_cast< int >(val2);
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (arg1)->GetRowGridLinePen(arg2);
13439 wxPyEndAllowThreads(__tstate);
13440 if (PyErr_Occurred()) SWIG_fail;
13441 }
13442 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj = 0;
13451 wxGrid *arg1 = (wxGrid *) 0 ;
13452 int arg2 ;
13453 wxPen result;
13454 void *argp1 = 0 ;
13455 int res1 = 0 ;
13456 int val2 ;
13457 int ecode2 = 0 ;
13458 PyObject * obj0 = 0 ;
13459 PyObject * obj1 = 0 ;
13460 char * kwnames[] = {
13461 (char *) "self",(char *) "col", NULL
13462 };
13463
13464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13466 if (!SWIG_IsOK(res1)) {
13467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13468 }
13469 arg1 = reinterpret_cast< wxGrid * >(argp1);
13470 ecode2 = SWIG_AsVal_int(obj1, &val2);
13471 if (!SWIG_IsOK(ecode2)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13473 }
13474 arg2 = static_cast< int >(val2);
13475 {
13476 PyThreadState* __tstate = wxPyBeginAllowThreads();
13477 result = (arg1)->GetColGridLinePen(arg2);
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13482 return resultobj;
13483 fail:
13484 return NULL;
13485 }
13486
13487
13488 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13489 PyObject *resultobj = 0;
13490 wxGrid *arg1 = (wxGrid *) 0 ;
13491 wxColour result;
13492 void *argp1 = 0 ;
13493 int res1 = 0 ;
13494 PyObject *swig_obj[1] ;
13495
13496 if (!args) SWIG_fail;
13497 swig_obj[0] = args;
13498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13499 if (!SWIG_IsOK(res1)) {
13500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13501 }
13502 arg1 = reinterpret_cast< wxGrid * >(argp1);
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (arg1)->GetCellHighlightColour();
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13510 return resultobj;
13511 fail:
13512 return NULL;
13513 }
13514
13515
13516 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13517 PyObject *resultobj = 0;
13518 wxGrid *arg1 = (wxGrid *) 0 ;
13519 int result;
13520 void *argp1 = 0 ;
13521 int res1 = 0 ;
13522 PyObject *swig_obj[1] ;
13523
13524 if (!args) SWIG_fail;
13525 swig_obj[0] = args;
13526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13527 if (!SWIG_IsOK(res1)) {
13528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13529 }
13530 arg1 = reinterpret_cast< wxGrid * >(argp1);
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 result = (int)(arg1)->GetCellHighlightPenWidth();
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 resultobj = SWIG_From_int(static_cast< int >(result));
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13545 PyObject *resultobj = 0;
13546 wxGrid *arg1 = (wxGrid *) 0 ;
13547 int result;
13548 void *argp1 = 0 ;
13549 int res1 = 0 ;
13550 PyObject *swig_obj[1] ;
13551
13552 if (!args) SWIG_fail;
13553 swig_obj[0] = args;
13554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13555 if (!SWIG_IsOK(res1)) {
13556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13557 }
13558 arg1 = reinterpret_cast< wxGrid * >(argp1);
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (int)(arg1)->GetCellHighlightROPenWidth();
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 resultobj = SWIG_From_int(static_cast< int >(result));
13566 return resultobj;
13567 fail:
13568 return NULL;
13569 }
13570
13571
13572 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj = 0;
13574 wxGrid *arg1 = (wxGrid *) 0 ;
13575 int arg2 ;
13576 void *argp1 = 0 ;
13577 int res1 = 0 ;
13578 int val2 ;
13579 int ecode2 = 0 ;
13580 PyObject * obj0 = 0 ;
13581 PyObject * obj1 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "width", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13590 }
13591 arg1 = reinterpret_cast< wxGrid * >(argp1);
13592 ecode2 = SWIG_AsVal_int(obj1, &val2);
13593 if (!SWIG_IsOK(ecode2)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13595 }
13596 arg2 = static_cast< int >(val2);
13597 {
13598 PyThreadState* __tstate = wxPyBeginAllowThreads();
13599 (arg1)->SetRowLabelSize(arg2);
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 resultobj = SWIG_Py_Void();
13604 return resultobj;
13605 fail:
13606 return NULL;
13607 }
13608
13609
13610 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj = 0;
13612 wxGrid *arg1 = (wxGrid *) 0 ;
13613 int arg2 ;
13614 void *argp1 = 0 ;
13615 int res1 = 0 ;
13616 int val2 ;
13617 int ecode2 = 0 ;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 char * kwnames[] = {
13621 (char *) "self",(char *) "height", NULL
13622 };
13623
13624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13626 if (!SWIG_IsOK(res1)) {
13627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13628 }
13629 arg1 = reinterpret_cast< wxGrid * >(argp1);
13630 ecode2 = SWIG_AsVal_int(obj1, &val2);
13631 if (!SWIG_IsOK(ecode2)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13633 }
13634 arg2 = static_cast< int >(val2);
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 (arg1)->SetColLabelSize(arg2);
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj = 0;
13650 wxGrid *arg1 = (wxGrid *) 0 ;
13651 wxColour *arg2 = 0 ;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 wxColour temp2 ;
13655 PyObject * obj0 = 0 ;
13656 PyObject * obj1 = 0 ;
13657 char * kwnames[] = {
13658 (char *) "self",(char *)"arg2", NULL
13659 };
13660
13661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13663 if (!SWIG_IsOK(res1)) {
13664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13665 }
13666 arg1 = reinterpret_cast< wxGrid * >(argp1);
13667 {
13668 arg2 = &temp2;
13669 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13670 }
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_Py_Void();
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 wxGrid *arg1 = (wxGrid *) 0 ;
13687 wxColour *arg2 = 0 ;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 wxColour temp2 ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 char * kwnames[] = {
13694 (char *) "self",(char *)"arg2", NULL
13695 };
13696
13697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13699 if (!SWIG_IsOK(res1)) {
13700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13701 }
13702 arg1 = reinterpret_cast< wxGrid * >(argp1);
13703 {
13704 arg2 = &temp2;
13705 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13706 }
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 resultobj = SWIG_Py_Void();
13714 return resultobj;
13715 fail:
13716 return NULL;
13717 }
13718
13719
13720 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj = 0;
13722 wxGrid *arg1 = (wxGrid *) 0 ;
13723 wxFont *arg2 = 0 ;
13724 void *argp1 = 0 ;
13725 int res1 = 0 ;
13726 void *argp2 = 0 ;
13727 int res2 = 0 ;
13728 PyObject * obj0 = 0 ;
13729 PyObject * obj1 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *)"arg2", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13738 }
13739 arg1 = reinterpret_cast< wxGrid * >(argp1);
13740 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13741 if (!SWIG_IsOK(res2)) {
13742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13743 }
13744 if (!argp2) {
13745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13746 }
13747 arg2 = reinterpret_cast< wxFont * >(argp2);
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 (arg1)->SetLabelFont((wxFont const &)*arg2);
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 resultobj = SWIG_Py_Void();
13755 return resultobj;
13756 fail:
13757 return NULL;
13758 }
13759
13760
13761 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13762 PyObject *resultobj = 0;
13763 wxGrid *arg1 = (wxGrid *) 0 ;
13764 int arg2 ;
13765 int arg3 ;
13766 void *argp1 = 0 ;
13767 int res1 = 0 ;
13768 int val2 ;
13769 int ecode2 = 0 ;
13770 int val3 ;
13771 int ecode3 = 0 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 char * kwnames[] = {
13776 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13777 };
13778
13779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13781 if (!SWIG_IsOK(res1)) {
13782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13783 }
13784 arg1 = reinterpret_cast< wxGrid * >(argp1);
13785 ecode2 = SWIG_AsVal_int(obj1, &val2);
13786 if (!SWIG_IsOK(ecode2)) {
13787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13788 }
13789 arg2 = static_cast< int >(val2);
13790 ecode3 = SWIG_AsVal_int(obj2, &val3);
13791 if (!SWIG_IsOK(ecode3)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13793 }
13794 arg3 = static_cast< int >(val3);
13795 {
13796 PyThreadState* __tstate = wxPyBeginAllowThreads();
13797 (arg1)->SetRowLabelAlignment(arg2,arg3);
13798 wxPyEndAllowThreads(__tstate);
13799 if (PyErr_Occurred()) SWIG_fail;
13800 }
13801 resultobj = SWIG_Py_Void();
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj = 0;
13810 wxGrid *arg1 = (wxGrid *) 0 ;
13811 int arg2 ;
13812 int arg3 ;
13813 void *argp1 = 0 ;
13814 int res1 = 0 ;
13815 int val2 ;
13816 int ecode2 = 0 ;
13817 int val3 ;
13818 int ecode3 = 0 ;
13819 PyObject * obj0 = 0 ;
13820 PyObject * obj1 = 0 ;
13821 PyObject * obj2 = 0 ;
13822 char * kwnames[] = {
13823 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13824 };
13825
13826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13828 if (!SWIG_IsOK(res1)) {
13829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13830 }
13831 arg1 = reinterpret_cast< wxGrid * >(argp1);
13832 ecode2 = SWIG_AsVal_int(obj1, &val2);
13833 if (!SWIG_IsOK(ecode2)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13835 }
13836 arg2 = static_cast< int >(val2);
13837 ecode3 = SWIG_AsVal_int(obj2, &val3);
13838 if (!SWIG_IsOK(ecode3)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13840 }
13841 arg3 = static_cast< int >(val3);
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 (arg1)->SetColLabelAlignment(arg2,arg3);
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_Py_Void();
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxGrid *arg1 = (wxGrid *) 0 ;
13858 int arg2 ;
13859 void *argp1 = 0 ;
13860 int res1 = 0 ;
13861 int val2 ;
13862 int ecode2 = 0 ;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 char * kwnames[] = {
13866 (char *) "self",(char *) "textOrientation", NULL
13867 };
13868
13869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13871 if (!SWIG_IsOK(res1)) {
13872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13873 }
13874 arg1 = reinterpret_cast< wxGrid * >(argp1);
13875 ecode2 = SWIG_AsVal_int(obj1, &val2);
13876 if (!SWIG_IsOK(ecode2)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13878 }
13879 arg2 = static_cast< int >(val2);
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->SetColLabelTextOrientation(arg2);
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_Py_Void();
13887 return resultobj;
13888 fail:
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxGrid *arg1 = (wxGrid *) 0 ;
13896 int arg2 ;
13897 wxString *arg3 = 0 ;
13898 void *argp1 = 0 ;
13899 int res1 = 0 ;
13900 int val2 ;
13901 int ecode2 = 0 ;
13902 bool temp3 = false ;
13903 PyObject * obj0 = 0 ;
13904 PyObject * obj1 = 0 ;
13905 PyObject * obj2 = 0 ;
13906 char * kwnames[] = {
13907 (char *) "self",(char *) "row",(char *)"arg3", NULL
13908 };
13909
13910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13912 if (!SWIG_IsOK(res1)) {
13913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13914 }
13915 arg1 = reinterpret_cast< wxGrid * >(argp1);
13916 ecode2 = SWIG_AsVal_int(obj1, &val2);
13917 if (!SWIG_IsOK(ecode2)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13919 }
13920 arg2 = static_cast< int >(val2);
13921 {
13922 arg3 = wxString_in_helper(obj2);
13923 if (arg3 == NULL) SWIG_fail;
13924 temp3 = true;
13925 }
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp3)
13935 delete arg3;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp3)
13941 delete arg3;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj = 0;
13949 wxGrid *arg1 = (wxGrid *) 0 ;
13950 int arg2 ;
13951 wxString *arg3 = 0 ;
13952 void *argp1 = 0 ;
13953 int res1 = 0 ;
13954 int val2 ;
13955 int ecode2 = 0 ;
13956 bool temp3 = false ;
13957 PyObject * obj0 = 0 ;
13958 PyObject * obj1 = 0 ;
13959 PyObject * obj2 = 0 ;
13960 char * kwnames[] = {
13961 (char *) "self",(char *) "col",(char *)"arg3", NULL
13962 };
13963
13964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13966 if (!SWIG_IsOK(res1)) {
13967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13968 }
13969 arg1 = reinterpret_cast< wxGrid * >(argp1);
13970 ecode2 = SWIG_AsVal_int(obj1, &val2);
13971 if (!SWIG_IsOK(ecode2)) {
13972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13973 }
13974 arg2 = static_cast< int >(val2);
13975 {
13976 arg3 = wxString_in_helper(obj2);
13977 if (arg3 == NULL) SWIG_fail;
13978 temp3 = true;
13979 }
13980 {
13981 PyThreadState* __tstate = wxPyBeginAllowThreads();
13982 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13983 wxPyEndAllowThreads(__tstate);
13984 if (PyErr_Occurred()) SWIG_fail;
13985 }
13986 resultobj = SWIG_Py_Void();
13987 {
13988 if (temp3)
13989 delete arg3;
13990 }
13991 return resultobj;
13992 fail:
13993 {
13994 if (temp3)
13995 delete arg3;
13996 }
13997 return NULL;
13998 }
13999
14000
14001 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj = 0;
14003 wxGrid *arg1 = (wxGrid *) 0 ;
14004 wxColour *arg2 = 0 ;
14005 void *argp1 = 0 ;
14006 int res1 = 0 ;
14007 wxColour temp2 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 char * kwnames[] = {
14011 (char *) "self",(char *)"arg2", NULL
14012 };
14013
14014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14016 if (!SWIG_IsOK(res1)) {
14017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14018 }
14019 arg1 = reinterpret_cast< wxGrid * >(argp1);
14020 {
14021 arg2 = &temp2;
14022 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14023 }
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 resultobj = SWIG_Py_Void();
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj = 0;
14039 wxGrid *arg1 = (wxGrid *) 0 ;
14040 wxColour *arg2 = 0 ;
14041 void *argp1 = 0 ;
14042 int res1 = 0 ;
14043 wxColour temp2 ;
14044 PyObject * obj0 = 0 ;
14045 PyObject * obj1 = 0 ;
14046 char * kwnames[] = {
14047 (char *) "self",(char *)"arg2", NULL
14048 };
14049
14050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14052 if (!SWIG_IsOK(res1)) {
14053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14054 }
14055 arg1 = reinterpret_cast< wxGrid * >(argp1);
14056 {
14057 arg2 = &temp2;
14058 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14059 }
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 resultobj = SWIG_Py_Void();
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj = 0;
14075 wxGrid *arg1 = (wxGrid *) 0 ;
14076 int arg2 ;
14077 void *argp1 = 0 ;
14078 int res1 = 0 ;
14079 int val2 ;
14080 int ecode2 = 0 ;
14081 PyObject * obj0 = 0 ;
14082 PyObject * obj1 = 0 ;
14083 char * kwnames[] = {
14084 (char *) "self",(char *) "width", NULL
14085 };
14086
14087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14089 if (!SWIG_IsOK(res1)) {
14090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14091 }
14092 arg1 = reinterpret_cast< wxGrid * >(argp1);
14093 ecode2 = SWIG_AsVal_int(obj1, &val2);
14094 if (!SWIG_IsOK(ecode2)) {
14095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14096 }
14097 arg2 = static_cast< int >(val2);
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 (arg1)->SetCellHighlightPenWidth(arg2);
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 resultobj = SWIG_Py_Void();
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14112 PyObject *resultobj = 0;
14113 wxGrid *arg1 = (wxGrid *) 0 ;
14114 int arg2 ;
14115 void *argp1 = 0 ;
14116 int res1 = 0 ;
14117 int val2 ;
14118 int ecode2 = 0 ;
14119 PyObject * obj0 = 0 ;
14120 PyObject * obj1 = 0 ;
14121 char * kwnames[] = {
14122 (char *) "self",(char *) "width", NULL
14123 };
14124
14125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14127 if (!SWIG_IsOK(res1)) {
14128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14129 }
14130 arg1 = reinterpret_cast< wxGrid * >(argp1);
14131 ecode2 = SWIG_AsVal_int(obj1, &val2);
14132 if (!SWIG_IsOK(ecode2)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14134 }
14135 arg2 = static_cast< int >(val2);
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 (arg1)->SetCellHighlightROPenWidth(arg2);
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_Py_Void();
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj = 0;
14151 wxGrid *arg1 = (wxGrid *) 0 ;
14152 bool arg2 = (bool) true ;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 bool val2 ;
14156 int ecode2 = 0 ;
14157 PyObject * obj0 = 0 ;
14158 PyObject * obj1 = 0 ;
14159 char * kwnames[] = {
14160 (char *) "self",(char *) "enable", NULL
14161 };
14162
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14167 }
14168 arg1 = reinterpret_cast< wxGrid * >(argp1);
14169 if (obj1) {
14170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14171 if (!SWIG_IsOK(ecode2)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14173 }
14174 arg2 = static_cast< bool >(val2);
14175 }
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 (arg1)->EnableDragRowSize(arg2);
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_Py_Void();
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14190 PyObject *resultobj = 0;
14191 wxGrid *arg1 = (wxGrid *) 0 ;
14192 void *argp1 = 0 ;
14193 int res1 = 0 ;
14194 PyObject *swig_obj[1] ;
14195
14196 if (!args) SWIG_fail;
14197 swig_obj[0] = args;
14198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14199 if (!SWIG_IsOK(res1)) {
14200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14201 }
14202 arg1 = reinterpret_cast< wxGrid * >(argp1);
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 (arg1)->DisableDragRowSize();
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 resultobj = SWIG_Py_Void();
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14217 PyObject *resultobj = 0;
14218 wxGrid *arg1 = (wxGrid *) 0 ;
14219 bool result;
14220 void *argp1 = 0 ;
14221 int res1 = 0 ;
14222 PyObject *swig_obj[1] ;
14223
14224 if (!args) SWIG_fail;
14225 swig_obj[0] = args;
14226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14227 if (!SWIG_IsOK(res1)) {
14228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14229 }
14230 arg1 = reinterpret_cast< wxGrid * >(argp1);
14231 {
14232 PyThreadState* __tstate = wxPyBeginAllowThreads();
14233 result = (bool)(arg1)->CanDragRowSize();
14234 wxPyEndAllowThreads(__tstate);
14235 if (PyErr_Occurred()) SWIG_fail;
14236 }
14237 {
14238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14239 }
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14247 PyObject *resultobj = 0;
14248 wxGrid *arg1 = (wxGrid *) 0 ;
14249 bool arg2 = (bool) true ;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 bool val2 ;
14253 int ecode2 = 0 ;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 char * kwnames[] = {
14257 (char *) "self",(char *) "enable", NULL
14258 };
14259
14260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14262 if (!SWIG_IsOK(res1)) {
14263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14264 }
14265 arg1 = reinterpret_cast< wxGrid * >(argp1);
14266 if (obj1) {
14267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14268 if (!SWIG_IsOK(ecode2)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14270 }
14271 arg2 = static_cast< bool >(val2);
14272 }
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 (arg1)->EnableDragColSize(arg2);
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 resultobj = SWIG_Py_Void();
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14287 PyObject *resultobj = 0;
14288 wxGrid *arg1 = (wxGrid *) 0 ;
14289 void *argp1 = 0 ;
14290 int res1 = 0 ;
14291 PyObject *swig_obj[1] ;
14292
14293 if (!args) SWIG_fail;
14294 swig_obj[0] = args;
14295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14296 if (!SWIG_IsOK(res1)) {
14297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14298 }
14299 arg1 = reinterpret_cast< wxGrid * >(argp1);
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 (arg1)->DisableDragColSize();
14303 wxPyEndAllowThreads(__tstate);
14304 if (PyErr_Occurred()) SWIG_fail;
14305 }
14306 resultobj = SWIG_Py_Void();
14307 return resultobj;
14308 fail:
14309 return NULL;
14310 }
14311
14312
14313 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14314 PyObject *resultobj = 0;
14315 wxGrid *arg1 = (wxGrid *) 0 ;
14316 bool result;
14317 void *argp1 = 0 ;
14318 int res1 = 0 ;
14319 PyObject *swig_obj[1] ;
14320
14321 if (!args) SWIG_fail;
14322 swig_obj[0] = args;
14323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14324 if (!SWIG_IsOK(res1)) {
14325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14326 }
14327 arg1 = reinterpret_cast< wxGrid * >(argp1);
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 result = (bool)(arg1)->CanDragColSize();
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 {
14335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14336 }
14337 return resultobj;
14338 fail:
14339 return NULL;
14340 }
14341
14342
14343 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14344 PyObject *resultobj = 0;
14345 wxGrid *arg1 = (wxGrid *) 0 ;
14346 bool arg2 = (bool) true ;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 bool val2 ;
14350 int ecode2 = 0 ;
14351 PyObject * obj0 = 0 ;
14352 PyObject * obj1 = 0 ;
14353 char * kwnames[] = {
14354 (char *) "self",(char *) "enable", NULL
14355 };
14356
14357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14359 if (!SWIG_IsOK(res1)) {
14360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14361 }
14362 arg1 = reinterpret_cast< wxGrid * >(argp1);
14363 if (obj1) {
14364 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14365 if (!SWIG_IsOK(ecode2)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14367 }
14368 arg2 = static_cast< bool >(val2);
14369 }
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 (arg1)->EnableDragColMove(arg2);
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 resultobj = SWIG_Py_Void();
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14384 PyObject *resultobj = 0;
14385 wxGrid *arg1 = (wxGrid *) 0 ;
14386 void *argp1 = 0 ;
14387 int res1 = 0 ;
14388 PyObject *swig_obj[1] ;
14389
14390 if (!args) SWIG_fail;
14391 swig_obj[0] = args;
14392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14395 }
14396 arg1 = reinterpret_cast< wxGrid * >(argp1);
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 (arg1)->DisableDragColMove();
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = SWIG_Py_Void();
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14411 PyObject *resultobj = 0;
14412 wxGrid *arg1 = (wxGrid *) 0 ;
14413 bool result;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 PyObject *swig_obj[1] ;
14417
14418 if (!args) SWIG_fail;
14419 swig_obj[0] = args;
14420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14421 if (!SWIG_IsOK(res1)) {
14422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14423 }
14424 arg1 = reinterpret_cast< wxGrid * >(argp1);
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (bool)(arg1)->CanDragColMove();
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 {
14432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14433 }
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj = 0;
14442 wxGrid *arg1 = (wxGrid *) 0 ;
14443 bool arg2 = (bool) true ;
14444 void *argp1 = 0 ;
14445 int res1 = 0 ;
14446 bool val2 ;
14447 int ecode2 = 0 ;
14448 PyObject * obj0 = 0 ;
14449 PyObject * obj1 = 0 ;
14450 char * kwnames[] = {
14451 (char *) "self",(char *) "enable", NULL
14452 };
14453
14454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14456 if (!SWIG_IsOK(res1)) {
14457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14458 }
14459 arg1 = reinterpret_cast< wxGrid * >(argp1);
14460 if (obj1) {
14461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14462 if (!SWIG_IsOK(ecode2)) {
14463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14464 }
14465 arg2 = static_cast< bool >(val2);
14466 }
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 (arg1)->EnableDragGridSize(arg2);
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = SWIG_Py_Void();
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14481 PyObject *resultobj = 0;
14482 wxGrid *arg1 = (wxGrid *) 0 ;
14483 void *argp1 = 0 ;
14484 int res1 = 0 ;
14485 PyObject *swig_obj[1] ;
14486
14487 if (!args) SWIG_fail;
14488 swig_obj[0] = args;
14489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14492 }
14493 arg1 = reinterpret_cast< wxGrid * >(argp1);
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 (arg1)->DisableDragGridSize();
14497 wxPyEndAllowThreads(__tstate);
14498 if (PyErr_Occurred()) SWIG_fail;
14499 }
14500 resultobj = SWIG_Py_Void();
14501 return resultobj;
14502 fail:
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14508 PyObject *resultobj = 0;
14509 wxGrid *arg1 = (wxGrid *) 0 ;
14510 bool result;
14511 void *argp1 = 0 ;
14512 int res1 = 0 ;
14513 PyObject *swig_obj[1] ;
14514
14515 if (!args) SWIG_fail;
14516 swig_obj[0] = args;
14517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14518 if (!SWIG_IsOK(res1)) {
14519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14520 }
14521 arg1 = reinterpret_cast< wxGrid * >(argp1);
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (bool)(arg1)->CanDragGridSize();
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 {
14529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14530 }
14531 return resultobj;
14532 fail:
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = 0;
14539 wxGrid *arg1 = (wxGrid *) 0 ;
14540 bool arg2 = (bool) true ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 bool val2 ;
14544 int ecode2 = 0 ;
14545 PyObject * obj0 = 0 ;
14546 PyObject * obj1 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "enable", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14555 }
14556 arg1 = reinterpret_cast< wxGrid * >(argp1);
14557 if (obj1) {
14558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14559 if (!SWIG_IsOK(ecode2)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14561 }
14562 arg2 = static_cast< bool >(val2);
14563 }
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 (arg1)->EnableDragCell(arg2);
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 resultobj = SWIG_Py_Void();
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14578 PyObject *resultobj = 0;
14579 wxGrid *arg1 = (wxGrid *) 0 ;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 PyObject *swig_obj[1] ;
14583
14584 if (!args) SWIG_fail;
14585 swig_obj[0] = args;
14586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14589 }
14590 arg1 = reinterpret_cast< wxGrid * >(argp1);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 (arg1)->DisableDragCell();
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = SWIG_Py_Void();
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14605 PyObject *resultobj = 0;
14606 wxGrid *arg1 = (wxGrid *) 0 ;
14607 bool result;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 PyObject *swig_obj[1] ;
14611
14612 if (!args) SWIG_fail;
14613 swig_obj[0] = args;
14614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14615 if (!SWIG_IsOK(res1)) {
14616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14617 }
14618 arg1 = reinterpret_cast< wxGrid * >(argp1);
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 result = (bool)(arg1)->CanDragCell();
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 {
14626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14627 }
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxGrid *arg1 = (wxGrid *) 0 ;
14637 int arg2 ;
14638 int arg3 ;
14639 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14640 void *argp1 = 0 ;
14641 int res1 = 0 ;
14642 int val2 ;
14643 int ecode2 = 0 ;
14644 int val3 ;
14645 int ecode3 = 0 ;
14646 void *argp4 = 0 ;
14647 int res4 = 0 ;
14648 PyObject * obj0 = 0 ;
14649 PyObject * obj1 = 0 ;
14650 PyObject * obj2 = 0 ;
14651 PyObject * obj3 = 0 ;
14652 char * kwnames[] = {
14653 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14654 };
14655
14656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14658 if (!SWIG_IsOK(res1)) {
14659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14660 }
14661 arg1 = reinterpret_cast< wxGrid * >(argp1);
14662 ecode2 = SWIG_AsVal_int(obj1, &val2);
14663 if (!SWIG_IsOK(ecode2)) {
14664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14665 }
14666 arg2 = static_cast< int >(val2);
14667 ecode3 = SWIG_AsVal_int(obj2, &val3);
14668 if (!SWIG_IsOK(ecode3)) {
14669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14670 }
14671 arg3 = static_cast< int >(val3);
14672 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14673 if (!SWIG_IsOK(res4)) {
14674 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14675 }
14676 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->SetAttr(arg2,arg3,arg4);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_Py_Void();
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxGrid *arg1 = (wxGrid *) 0 ;
14693 int arg2 ;
14694 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14695 void *argp1 = 0 ;
14696 int res1 = 0 ;
14697 int val2 ;
14698 int ecode2 = 0 ;
14699 void *argp3 = 0 ;
14700 int res3 = 0 ;
14701 PyObject * obj0 = 0 ;
14702 PyObject * obj1 = 0 ;
14703 PyObject * obj2 = 0 ;
14704 char * kwnames[] = {
14705 (char *) "self",(char *) "row",(char *) "attr", NULL
14706 };
14707
14708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14710 if (!SWIG_IsOK(res1)) {
14711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14712 }
14713 arg1 = reinterpret_cast< wxGrid * >(argp1);
14714 ecode2 = SWIG_AsVal_int(obj1, &val2);
14715 if (!SWIG_IsOK(ecode2)) {
14716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14717 }
14718 arg2 = static_cast< int >(val2);
14719 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14720 if (!SWIG_IsOK(res3)) {
14721 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14722 }
14723 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 (arg1)->SetRowAttr(arg2,arg3);
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 resultobj = SWIG_Py_Void();
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14738 PyObject *resultobj = 0;
14739 wxGrid *arg1 = (wxGrid *) 0 ;
14740 int arg2 ;
14741 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14742 void *argp1 = 0 ;
14743 int res1 = 0 ;
14744 int val2 ;
14745 int ecode2 = 0 ;
14746 void *argp3 = 0 ;
14747 int res3 = 0 ;
14748 PyObject * obj0 = 0 ;
14749 PyObject * obj1 = 0 ;
14750 PyObject * obj2 = 0 ;
14751 char * kwnames[] = {
14752 (char *) "self",(char *) "col",(char *) "attr", NULL
14753 };
14754
14755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14757 if (!SWIG_IsOK(res1)) {
14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14759 }
14760 arg1 = reinterpret_cast< wxGrid * >(argp1);
14761 ecode2 = SWIG_AsVal_int(obj1, &val2);
14762 if (!SWIG_IsOK(ecode2)) {
14763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14764 }
14765 arg2 = static_cast< int >(val2);
14766 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14767 if (!SWIG_IsOK(res3)) {
14768 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14769 }
14770 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14771 {
14772 PyThreadState* __tstate = wxPyBeginAllowThreads();
14773 (arg1)->SetColAttr(arg2,arg3);
14774 wxPyEndAllowThreads(__tstate);
14775 if (PyErr_Occurred()) SWIG_fail;
14776 }
14777 resultobj = SWIG_Py_Void();
14778 return resultobj;
14779 fail:
14780 return NULL;
14781 }
14782
14783
14784 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14785 PyObject *resultobj = 0;
14786 wxGrid *arg1 = (wxGrid *) 0 ;
14787 int arg2 ;
14788 int arg3 ;
14789 wxGridCellAttr *result = 0 ;
14790 void *argp1 = 0 ;
14791 int res1 = 0 ;
14792 int val2 ;
14793 int ecode2 = 0 ;
14794 int val3 ;
14795 int ecode3 = 0 ;
14796 PyObject * obj0 = 0 ;
14797 PyObject * obj1 = 0 ;
14798 PyObject * obj2 = 0 ;
14799 char * kwnames[] = {
14800 (char *) "self",(char *) "row",(char *) "col", NULL
14801 };
14802
14803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14805 if (!SWIG_IsOK(res1)) {
14806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14807 }
14808 arg1 = reinterpret_cast< wxGrid * >(argp1);
14809 ecode2 = SWIG_AsVal_int(obj1, &val2);
14810 if (!SWIG_IsOK(ecode2)) {
14811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14812 }
14813 arg2 = static_cast< int >(val2);
14814 ecode3 = SWIG_AsVal_int(obj2, &val3);
14815 if (!SWIG_IsOK(ecode3)) {
14816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14817 }
14818 arg3 = static_cast< int >(val3);
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14822 wxPyEndAllowThreads(__tstate);
14823 if (PyErr_Occurred()) SWIG_fail;
14824 }
14825 {
14826 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14827 }
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj = 0;
14836 wxGrid *arg1 = (wxGrid *) 0 ;
14837 int arg2 ;
14838 void *argp1 = 0 ;
14839 int res1 = 0 ;
14840 int val2 ;
14841 int ecode2 = 0 ;
14842 PyObject * obj0 = 0 ;
14843 PyObject * obj1 = 0 ;
14844 char * kwnames[] = {
14845 (char *) "self",(char *) "col", NULL
14846 };
14847
14848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14850 if (!SWIG_IsOK(res1)) {
14851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14852 }
14853 arg1 = reinterpret_cast< wxGrid * >(argp1);
14854 ecode2 = SWIG_AsVal_int(obj1, &val2);
14855 if (!SWIG_IsOK(ecode2)) {
14856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14857 }
14858 arg2 = static_cast< int >(val2);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 (arg1)->SetColFormatBool(arg2);
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 resultobj = SWIG_Py_Void();
14866 return resultobj;
14867 fail:
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14873 PyObject *resultobj = 0;
14874 wxGrid *arg1 = (wxGrid *) 0 ;
14875 int arg2 ;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 int val2 ;
14879 int ecode2 = 0 ;
14880 PyObject * obj0 = 0 ;
14881 PyObject * obj1 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "self",(char *) "col", NULL
14884 };
14885
14886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14888 if (!SWIG_IsOK(res1)) {
14889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14890 }
14891 arg1 = reinterpret_cast< wxGrid * >(argp1);
14892 ecode2 = SWIG_AsVal_int(obj1, &val2);
14893 if (!SWIG_IsOK(ecode2)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14895 }
14896 arg2 = static_cast< int >(val2);
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 (arg1)->SetColFormatNumber(arg2);
14900 wxPyEndAllowThreads(__tstate);
14901 if (PyErr_Occurred()) SWIG_fail;
14902 }
14903 resultobj = SWIG_Py_Void();
14904 return resultobj;
14905 fail:
14906 return NULL;
14907 }
14908
14909
14910 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14911 PyObject *resultobj = 0;
14912 wxGrid *arg1 = (wxGrid *) 0 ;
14913 int arg2 ;
14914 int arg3 = (int) -1 ;
14915 int arg4 = (int) -1 ;
14916 void *argp1 = 0 ;
14917 int res1 = 0 ;
14918 int val2 ;
14919 int ecode2 = 0 ;
14920 int val3 ;
14921 int ecode3 = 0 ;
14922 int val4 ;
14923 int ecode4 = 0 ;
14924 PyObject * obj0 = 0 ;
14925 PyObject * obj1 = 0 ;
14926 PyObject * obj2 = 0 ;
14927 PyObject * obj3 = 0 ;
14928 char * kwnames[] = {
14929 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14930 };
14931
14932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14934 if (!SWIG_IsOK(res1)) {
14935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14936 }
14937 arg1 = reinterpret_cast< wxGrid * >(argp1);
14938 ecode2 = SWIG_AsVal_int(obj1, &val2);
14939 if (!SWIG_IsOK(ecode2)) {
14940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14941 }
14942 arg2 = static_cast< int >(val2);
14943 if (obj2) {
14944 ecode3 = SWIG_AsVal_int(obj2, &val3);
14945 if (!SWIG_IsOK(ecode3)) {
14946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14947 }
14948 arg3 = static_cast< int >(val3);
14949 }
14950 if (obj3) {
14951 ecode4 = SWIG_AsVal_int(obj3, &val4);
14952 if (!SWIG_IsOK(ecode4)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14954 }
14955 arg4 = static_cast< int >(val4);
14956 }
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 resultobj = SWIG_Py_Void();
14964 return resultobj;
14965 fail:
14966 return NULL;
14967 }
14968
14969
14970 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14971 PyObject *resultobj = 0;
14972 wxGrid *arg1 = (wxGrid *) 0 ;
14973 int arg2 ;
14974 wxString *arg3 = 0 ;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 int val2 ;
14978 int ecode2 = 0 ;
14979 bool temp3 = false ;
14980 PyObject * obj0 = 0 ;
14981 PyObject * obj1 = 0 ;
14982 PyObject * obj2 = 0 ;
14983 char * kwnames[] = {
14984 (char *) "self",(char *) "col",(char *) "typeName", NULL
14985 };
14986
14987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14989 if (!SWIG_IsOK(res1)) {
14990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14991 }
14992 arg1 = reinterpret_cast< wxGrid * >(argp1);
14993 ecode2 = SWIG_AsVal_int(obj1, &val2);
14994 if (!SWIG_IsOK(ecode2)) {
14995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14996 }
14997 arg2 = static_cast< int >(val2);
14998 {
14999 arg3 = wxString_in_helper(obj2);
15000 if (arg3 == NULL) SWIG_fail;
15001 temp3 = true;
15002 }
15003 {
15004 PyThreadState* __tstate = wxPyBeginAllowThreads();
15005 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15006 wxPyEndAllowThreads(__tstate);
15007 if (PyErr_Occurred()) SWIG_fail;
15008 }
15009 resultobj = SWIG_Py_Void();
15010 {
15011 if (temp3)
15012 delete arg3;
15013 }
15014 return resultobj;
15015 fail:
15016 {
15017 if (temp3)
15018 delete arg3;
15019 }
15020 return NULL;
15021 }
15022
15023
15024 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj = 0;
15026 wxGrid *arg1 = (wxGrid *) 0 ;
15027 bool arg2 = (bool) true ;
15028 void *argp1 = 0 ;
15029 int res1 = 0 ;
15030 bool val2 ;
15031 int ecode2 = 0 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 char * kwnames[] = {
15035 (char *) "self",(char *) "enable", NULL
15036 };
15037
15038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15042 }
15043 arg1 = reinterpret_cast< wxGrid * >(argp1);
15044 if (obj1) {
15045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15046 if (!SWIG_IsOK(ecode2)) {
15047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15048 }
15049 arg2 = static_cast< bool >(val2);
15050 }
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 (arg1)->EnableGridLines(arg2);
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 resultobj = SWIG_Py_Void();
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15065 PyObject *resultobj = 0;
15066 wxGrid *arg1 = (wxGrid *) 0 ;
15067 bool result;
15068 void *argp1 = 0 ;
15069 int res1 = 0 ;
15070 PyObject *swig_obj[1] ;
15071
15072 if (!args) SWIG_fail;
15073 swig_obj[0] = args;
15074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15075 if (!SWIG_IsOK(res1)) {
15076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15077 }
15078 arg1 = reinterpret_cast< wxGrid * >(argp1);
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (bool)(arg1)->GridLinesEnabled();
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 {
15086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15087 }
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15095 PyObject *resultobj = 0;
15096 wxGrid *arg1 = (wxGrid *) 0 ;
15097 int result;
15098 void *argp1 = 0 ;
15099 int res1 = 0 ;
15100 PyObject *swig_obj[1] ;
15101
15102 if (!args) SWIG_fail;
15103 swig_obj[0] = args;
15104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15105 if (!SWIG_IsOK(res1)) {
15106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15107 }
15108 arg1 = reinterpret_cast< wxGrid * >(argp1);
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (int)(arg1)->GetDefaultRowSize();
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_From_int(static_cast< int >(result));
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj = 0;
15124 wxGrid *arg1 = (wxGrid *) 0 ;
15125 int arg2 ;
15126 int result;
15127 void *argp1 = 0 ;
15128 int res1 = 0 ;
15129 int val2 ;
15130 int ecode2 = 0 ;
15131 PyObject * obj0 = 0 ;
15132 PyObject * obj1 = 0 ;
15133 char * kwnames[] = {
15134 (char *) "self",(char *) "row", NULL
15135 };
15136
15137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15139 if (!SWIG_IsOK(res1)) {
15140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15141 }
15142 arg1 = reinterpret_cast< wxGrid * >(argp1);
15143 ecode2 = SWIG_AsVal_int(obj1, &val2);
15144 if (!SWIG_IsOK(ecode2)) {
15145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15146 }
15147 arg2 = static_cast< int >(val2);
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (int)(arg1)->GetRowSize(arg2);
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 resultobj = SWIG_From_int(static_cast< int >(result));
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15162 PyObject *resultobj = 0;
15163 wxGrid *arg1 = (wxGrid *) 0 ;
15164 int result;
15165 void *argp1 = 0 ;
15166 int res1 = 0 ;
15167 PyObject *swig_obj[1] ;
15168
15169 if (!args) SWIG_fail;
15170 swig_obj[0] = args;
15171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15172 if (!SWIG_IsOK(res1)) {
15173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15174 }
15175 arg1 = reinterpret_cast< wxGrid * >(argp1);
15176 {
15177 PyThreadState* __tstate = wxPyBeginAllowThreads();
15178 result = (int)(arg1)->GetDefaultColSize();
15179 wxPyEndAllowThreads(__tstate);
15180 if (PyErr_Occurred()) SWIG_fail;
15181 }
15182 resultobj = SWIG_From_int(static_cast< int >(result));
15183 return resultobj;
15184 fail:
15185 return NULL;
15186 }
15187
15188
15189 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15190 PyObject *resultobj = 0;
15191 wxGrid *arg1 = (wxGrid *) 0 ;
15192 int arg2 ;
15193 int result;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 int val2 ;
15197 int ecode2 = 0 ;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 char * kwnames[] = {
15201 (char *) "self",(char *) "col", NULL
15202 };
15203
15204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15208 }
15209 arg1 = reinterpret_cast< wxGrid * >(argp1);
15210 ecode2 = SWIG_AsVal_int(obj1, &val2);
15211 if (!SWIG_IsOK(ecode2)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15213 }
15214 arg2 = static_cast< int >(val2);
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (int)(arg1)->GetColSize(arg2);
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = SWIG_From_int(static_cast< int >(result));
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15229 PyObject *resultobj = 0;
15230 wxGrid *arg1 = (wxGrid *) 0 ;
15231 wxColour result;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 PyObject *swig_obj[1] ;
15235
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15239 if (!SWIG_IsOK(res1)) {
15240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15241 }
15242 arg1 = reinterpret_cast< wxGrid * >(argp1);
15243 {
15244 PyThreadState* __tstate = wxPyBeginAllowThreads();
15245 result = (arg1)->GetDefaultCellBackgroundColour();
15246 wxPyEndAllowThreads(__tstate);
15247 if (PyErr_Occurred()) SWIG_fail;
15248 }
15249 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15250 return resultobj;
15251 fail:
15252 return NULL;
15253 }
15254
15255
15256 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15257 PyObject *resultobj = 0;
15258 wxGrid *arg1 = (wxGrid *) 0 ;
15259 int arg2 ;
15260 int arg3 ;
15261 wxColour result;
15262 void *argp1 = 0 ;
15263 int res1 = 0 ;
15264 int val2 ;
15265 int ecode2 = 0 ;
15266 int val3 ;
15267 int ecode3 = 0 ;
15268 PyObject * obj0 = 0 ;
15269 PyObject * obj1 = 0 ;
15270 PyObject * obj2 = 0 ;
15271 char * kwnames[] = {
15272 (char *) "self",(char *) "row",(char *) "col", NULL
15273 };
15274
15275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15279 }
15280 arg1 = reinterpret_cast< wxGrid * >(argp1);
15281 ecode2 = SWIG_AsVal_int(obj1, &val2);
15282 if (!SWIG_IsOK(ecode2)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15284 }
15285 arg2 = static_cast< int >(val2);
15286 ecode3 = SWIG_AsVal_int(obj2, &val3);
15287 if (!SWIG_IsOK(ecode3)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15289 }
15290 arg3 = static_cast< int >(val3);
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15298 return resultobj;
15299 fail:
15300 return NULL;
15301 }
15302
15303
15304 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15305 PyObject *resultobj = 0;
15306 wxGrid *arg1 = (wxGrid *) 0 ;
15307 wxColour result;
15308 void *argp1 = 0 ;
15309 int res1 = 0 ;
15310 PyObject *swig_obj[1] ;
15311
15312 if (!args) SWIG_fail;
15313 swig_obj[0] = args;
15314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15317 }
15318 arg1 = reinterpret_cast< wxGrid * >(argp1);
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (arg1)->GetDefaultCellTextColour();
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj = 0;
15334 wxGrid *arg1 = (wxGrid *) 0 ;
15335 int arg2 ;
15336 int arg3 ;
15337 wxColour result;
15338 void *argp1 = 0 ;
15339 int res1 = 0 ;
15340 int val2 ;
15341 int ecode2 = 0 ;
15342 int val3 ;
15343 int ecode3 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 PyObject * obj2 = 0 ;
15347 char * kwnames[] = {
15348 (char *) "self",(char *) "row",(char *) "col", NULL
15349 };
15350
15351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15353 if (!SWIG_IsOK(res1)) {
15354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15355 }
15356 arg1 = reinterpret_cast< wxGrid * >(argp1);
15357 ecode2 = SWIG_AsVal_int(obj1, &val2);
15358 if (!SWIG_IsOK(ecode2)) {
15359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15360 }
15361 arg2 = static_cast< int >(val2);
15362 ecode3 = SWIG_AsVal_int(obj2, &val3);
15363 if (!SWIG_IsOK(ecode3)) {
15364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15365 }
15366 arg3 = static_cast< int >(val3);
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (arg1)->GetCellTextColour(arg2,arg3);
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15374 return resultobj;
15375 fail:
15376 return NULL;
15377 }
15378
15379
15380 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15381 PyObject *resultobj = 0;
15382 wxGrid *arg1 = (wxGrid *) 0 ;
15383 wxFont result;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject *swig_obj[1] ;
15387
15388 if (!args) SWIG_fail;
15389 swig_obj[0] = args;
15390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15393 }
15394 arg1 = reinterpret_cast< wxGrid * >(argp1);
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (arg1)->GetDefaultCellFont();
15398 wxPyEndAllowThreads(__tstate);
15399 if (PyErr_Occurred()) SWIG_fail;
15400 }
15401 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15402 return resultobj;
15403 fail:
15404 return NULL;
15405 }
15406
15407
15408 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15409 PyObject *resultobj = 0;
15410 wxGrid *arg1 = (wxGrid *) 0 ;
15411 int arg2 ;
15412 int arg3 ;
15413 wxFont result;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 int val2 ;
15417 int ecode2 = 0 ;
15418 int val3 ;
15419 int ecode3 = 0 ;
15420 PyObject * obj0 = 0 ;
15421 PyObject * obj1 = 0 ;
15422 PyObject * obj2 = 0 ;
15423 char * kwnames[] = {
15424 (char *) "self",(char *) "row",(char *) "col", NULL
15425 };
15426
15427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15429 if (!SWIG_IsOK(res1)) {
15430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15431 }
15432 arg1 = reinterpret_cast< wxGrid * >(argp1);
15433 ecode2 = SWIG_AsVal_int(obj1, &val2);
15434 if (!SWIG_IsOK(ecode2)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15436 }
15437 arg2 = static_cast< int >(val2);
15438 ecode3 = SWIG_AsVal_int(obj2, &val3);
15439 if (!SWIG_IsOK(ecode3)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15441 }
15442 arg3 = static_cast< int >(val3);
15443 {
15444 PyThreadState* __tstate = wxPyBeginAllowThreads();
15445 result = (arg1)->GetCellFont(arg2,arg3);
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15457 PyObject *resultobj = 0;
15458 wxGrid *arg1 = (wxGrid *) 0 ;
15459 int *arg2 = (int *) 0 ;
15460 int *arg3 = (int *) 0 ;
15461 void *argp1 = 0 ;
15462 int res1 = 0 ;
15463 int temp2 ;
15464 int res2 = SWIG_TMPOBJ ;
15465 int temp3 ;
15466 int res3 = SWIG_TMPOBJ ;
15467 PyObject *swig_obj[1] ;
15468
15469 arg2 = &temp2;
15470 arg3 = &temp3;
15471 if (!args) SWIG_fail;
15472 swig_obj[0] = args;
15473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15474 if (!SWIG_IsOK(res1)) {
15475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15476 }
15477 arg1 = reinterpret_cast< wxGrid * >(argp1);
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 resultobj = SWIG_Py_Void();
15485 if (SWIG_IsTmpObj(res2)) {
15486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15487 } else {
15488 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15490 }
15491 if (SWIG_IsTmpObj(res3)) {
15492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15493 } else {
15494 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15496 }
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = 0;
15505 wxGrid *arg1 = (wxGrid *) 0 ;
15506 int arg2 ;
15507 int arg3 ;
15508 int *arg4 = (int *) 0 ;
15509 int *arg5 = (int *) 0 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 int val2 ;
15513 int ecode2 = 0 ;
15514 int val3 ;
15515 int ecode3 = 0 ;
15516 int temp4 ;
15517 int res4 = SWIG_TMPOBJ ;
15518 int temp5 ;
15519 int res5 = SWIG_TMPOBJ ;
15520 PyObject * obj0 = 0 ;
15521 PyObject * obj1 = 0 ;
15522 PyObject * obj2 = 0 ;
15523 char * kwnames[] = {
15524 (char *) "self",(char *) "row",(char *) "col", NULL
15525 };
15526
15527 arg4 = &temp4;
15528 arg5 = &temp5;
15529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15531 if (!SWIG_IsOK(res1)) {
15532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15533 }
15534 arg1 = reinterpret_cast< wxGrid * >(argp1);
15535 ecode2 = SWIG_AsVal_int(obj1, &val2);
15536 if (!SWIG_IsOK(ecode2)) {
15537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15538 }
15539 arg2 = static_cast< int >(val2);
15540 ecode3 = SWIG_AsVal_int(obj2, &val3);
15541 if (!SWIG_IsOK(ecode3)) {
15542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15543 }
15544 arg3 = static_cast< int >(val3);
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 resultobj = SWIG_Py_Void();
15552 if (SWIG_IsTmpObj(res4)) {
15553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15554 } else {
15555 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15557 }
15558 if (SWIG_IsTmpObj(res5)) {
15559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15560 } else {
15561 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15563 }
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxGrid *arg1 = (wxGrid *) 0 ;
15573 bool result;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15583 }
15584 arg1 = reinterpret_cast< wxGrid * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (bool)(arg1)->GetDefaultCellOverflow();
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj = 0;
15602 wxGrid *arg1 = (wxGrid *) 0 ;
15603 int arg2 ;
15604 int arg3 ;
15605 bool result;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 int val2 ;
15609 int ecode2 = 0 ;
15610 int val3 ;
15611 int ecode3 = 0 ;
15612 PyObject * obj0 = 0 ;
15613 PyObject * obj1 = 0 ;
15614 PyObject * obj2 = 0 ;
15615 char * kwnames[] = {
15616 (char *) "self",(char *) "row",(char *) "col", NULL
15617 };
15618
15619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15621 if (!SWIG_IsOK(res1)) {
15622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15623 }
15624 arg1 = reinterpret_cast< wxGrid * >(argp1);
15625 ecode2 = SWIG_AsVal_int(obj1, &val2);
15626 if (!SWIG_IsOK(ecode2)) {
15627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15628 }
15629 arg2 = static_cast< int >(val2);
15630 ecode3 = SWIG_AsVal_int(obj2, &val3);
15631 if (!SWIG_IsOK(ecode3)) {
15632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15633 }
15634 arg3 = static_cast< int >(val3);
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj = 0;
15652 wxGrid *arg1 = (wxGrid *) 0 ;
15653 int arg2 ;
15654 int arg3 ;
15655 int *arg4 = (int *) 0 ;
15656 int *arg5 = (int *) 0 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 int val2 ;
15660 int ecode2 = 0 ;
15661 int val3 ;
15662 int ecode3 = 0 ;
15663 int temp4 ;
15664 int res4 = SWIG_TMPOBJ ;
15665 int temp5 ;
15666 int res5 = SWIG_TMPOBJ ;
15667 PyObject * obj0 = 0 ;
15668 PyObject * obj1 = 0 ;
15669 PyObject * obj2 = 0 ;
15670 char * kwnames[] = {
15671 (char *) "self",(char *) "row",(char *) "col", NULL
15672 };
15673
15674 arg4 = &temp4;
15675 arg5 = &temp5;
15676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15680 }
15681 arg1 = reinterpret_cast< wxGrid * >(argp1);
15682 ecode2 = SWIG_AsVal_int(obj1, &val2);
15683 if (!SWIG_IsOK(ecode2)) {
15684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15685 }
15686 arg2 = static_cast< int >(val2);
15687 ecode3 = SWIG_AsVal_int(obj2, &val3);
15688 if (!SWIG_IsOK(ecode3)) {
15689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15690 }
15691 arg3 = static_cast< int >(val3);
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 resultobj = SWIG_Py_Void();
15699 if (SWIG_IsTmpObj(res4)) {
15700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15701 } else {
15702 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15704 }
15705 if (SWIG_IsTmpObj(res5)) {
15706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15707 } else {
15708 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15710 }
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15718 PyObject *resultobj = 0;
15719 wxGrid *arg1 = (wxGrid *) 0 ;
15720 int arg2 ;
15721 bool arg3 = (bool) false ;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 int val2 ;
15725 int ecode2 = 0 ;
15726 bool val3 ;
15727 int ecode3 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 PyObject * obj2 = 0 ;
15731 char * kwnames[] = {
15732 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15733 };
15734
15735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15737 if (!SWIG_IsOK(res1)) {
15738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15739 }
15740 arg1 = reinterpret_cast< wxGrid * >(argp1);
15741 ecode2 = SWIG_AsVal_int(obj1, &val2);
15742 if (!SWIG_IsOK(ecode2)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15744 }
15745 arg2 = static_cast< int >(val2);
15746 if (obj2) {
15747 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15748 if (!SWIG_IsOK(ecode3)) {
15749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15750 }
15751 arg3 = static_cast< bool >(val3);
15752 }
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 (arg1)->SetDefaultRowSize(arg2,arg3);
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_Py_Void();
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15767 PyObject *resultobj = 0;
15768 wxGrid *arg1 = (wxGrid *) 0 ;
15769 int arg2 ;
15770 int arg3 ;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 int val2 ;
15774 int ecode2 = 0 ;
15775 int val3 ;
15776 int ecode3 = 0 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 PyObject * obj2 = 0 ;
15780 char * kwnames[] = {
15781 (char *) "self",(char *) "row",(char *) "height", NULL
15782 };
15783
15784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15788 }
15789 arg1 = reinterpret_cast< wxGrid * >(argp1);
15790 ecode2 = SWIG_AsVal_int(obj1, &val2);
15791 if (!SWIG_IsOK(ecode2)) {
15792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15793 }
15794 arg2 = static_cast< int >(val2);
15795 ecode3 = SWIG_AsVal_int(obj2, &val3);
15796 if (!SWIG_IsOK(ecode3)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15798 }
15799 arg3 = static_cast< int >(val3);
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 (arg1)->SetRowSize(arg2,arg3);
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 resultobj = SWIG_Py_Void();
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15814 PyObject *resultobj = 0;
15815 wxGrid *arg1 = (wxGrid *) 0 ;
15816 int arg2 ;
15817 bool arg3 = (bool) false ;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 int val2 ;
15821 int ecode2 = 0 ;
15822 bool val3 ;
15823 int ecode3 = 0 ;
15824 PyObject * obj0 = 0 ;
15825 PyObject * obj1 = 0 ;
15826 PyObject * obj2 = 0 ;
15827 char * kwnames[] = {
15828 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15829 };
15830
15831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15835 }
15836 arg1 = reinterpret_cast< wxGrid * >(argp1);
15837 ecode2 = SWIG_AsVal_int(obj1, &val2);
15838 if (!SWIG_IsOK(ecode2)) {
15839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15840 }
15841 arg2 = static_cast< int >(val2);
15842 if (obj2) {
15843 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15844 if (!SWIG_IsOK(ecode3)) {
15845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15846 }
15847 arg3 = static_cast< bool >(val3);
15848 }
15849 {
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 (arg1)->SetDefaultColSize(arg2,arg3);
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 resultobj = SWIG_Py_Void();
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj = 0;
15864 wxGrid *arg1 = (wxGrid *) 0 ;
15865 int arg2 ;
15866 int arg3 ;
15867 void *argp1 = 0 ;
15868 int res1 = 0 ;
15869 int val2 ;
15870 int ecode2 = 0 ;
15871 int val3 ;
15872 int ecode3 = 0 ;
15873 PyObject * obj0 = 0 ;
15874 PyObject * obj1 = 0 ;
15875 PyObject * obj2 = 0 ;
15876 char * kwnames[] = {
15877 (char *) "self",(char *) "col",(char *) "width", NULL
15878 };
15879
15880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15884 }
15885 arg1 = reinterpret_cast< wxGrid * >(argp1);
15886 ecode2 = SWIG_AsVal_int(obj1, &val2);
15887 if (!SWIG_IsOK(ecode2)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15889 }
15890 arg2 = static_cast< int >(val2);
15891 ecode3 = SWIG_AsVal_int(obj2, &val3);
15892 if (!SWIG_IsOK(ecode3)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15894 }
15895 arg3 = static_cast< int >(val3);
15896 {
15897 PyThreadState* __tstate = wxPyBeginAllowThreads();
15898 (arg1)->SetColSize(arg2,arg3);
15899 wxPyEndAllowThreads(__tstate);
15900 if (PyErr_Occurred()) SWIG_fail;
15901 }
15902 resultobj = SWIG_Py_Void();
15903 return resultobj;
15904 fail:
15905 return NULL;
15906 }
15907
15908
15909 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15910 PyObject *resultobj = 0;
15911 wxGrid *arg1 = (wxGrid *) 0 ;
15912 int arg2 ;
15913 int result;
15914 void *argp1 = 0 ;
15915 int res1 = 0 ;
15916 int val2 ;
15917 int ecode2 = 0 ;
15918 PyObject * obj0 = 0 ;
15919 PyObject * obj1 = 0 ;
15920 char * kwnames[] = {
15921 (char *) "self",(char *) "colPos", NULL
15922 };
15923
15924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15926 if (!SWIG_IsOK(res1)) {
15927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15928 }
15929 arg1 = reinterpret_cast< wxGrid * >(argp1);
15930 ecode2 = SWIG_AsVal_int(obj1, &val2);
15931 if (!SWIG_IsOK(ecode2)) {
15932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15933 }
15934 arg2 = static_cast< int >(val2);
15935 {
15936 PyThreadState* __tstate = wxPyBeginAllowThreads();
15937 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15938 wxPyEndAllowThreads(__tstate);
15939 if (PyErr_Occurred()) SWIG_fail;
15940 }
15941 resultobj = SWIG_From_int(static_cast< int >(result));
15942 return resultobj;
15943 fail:
15944 return NULL;
15945 }
15946
15947
15948 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15949 PyObject *resultobj = 0;
15950 wxGrid *arg1 = (wxGrid *) 0 ;
15951 int arg2 ;
15952 int arg3 ;
15953 void *argp1 = 0 ;
15954 int res1 = 0 ;
15955 int val2 ;
15956 int ecode2 = 0 ;
15957 int val3 ;
15958 int ecode3 = 0 ;
15959 PyObject * obj0 = 0 ;
15960 PyObject * obj1 = 0 ;
15961 PyObject * obj2 = 0 ;
15962 char * kwnames[] = {
15963 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15964 };
15965
15966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15968 if (!SWIG_IsOK(res1)) {
15969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15970 }
15971 arg1 = reinterpret_cast< wxGrid * >(argp1);
15972 ecode2 = SWIG_AsVal_int(obj1, &val2);
15973 if (!SWIG_IsOK(ecode2)) {
15974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15975 }
15976 arg2 = static_cast< int >(val2);
15977 ecode3 = SWIG_AsVal_int(obj2, &val3);
15978 if (!SWIG_IsOK(ecode3)) {
15979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15980 }
15981 arg3 = static_cast< int >(val3);
15982 {
15983 PyThreadState* __tstate = wxPyBeginAllowThreads();
15984 (arg1)->SetColPos(arg2,arg3);
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 resultobj = SWIG_Py_Void();
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj = 0;
15997 wxGrid *arg1 = (wxGrid *) 0 ;
15998 int arg2 ;
15999 int result;
16000 void *argp1 = 0 ;
16001 int res1 = 0 ;
16002 int val2 ;
16003 int ecode2 = 0 ;
16004 PyObject * obj0 = 0 ;
16005 PyObject * obj1 = 0 ;
16006 char * kwnames[] = {
16007 (char *) "self",(char *) "colID", NULL
16008 };
16009
16010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16012 if (!SWIG_IsOK(res1)) {
16013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16014 }
16015 arg1 = reinterpret_cast< wxGrid * >(argp1);
16016 ecode2 = SWIG_AsVal_int(obj1, &val2);
16017 if (!SWIG_IsOK(ecode2)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16019 }
16020 arg2 = static_cast< int >(val2);
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_From_int(static_cast< int >(result));
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj = 0;
16036 wxGrid *arg1 = (wxGrid *) 0 ;
16037 int arg2 ;
16038 bool arg3 = (bool) true ;
16039 void *argp1 = 0 ;
16040 int res1 = 0 ;
16041 int val2 ;
16042 int ecode2 = 0 ;
16043 bool val3 ;
16044 int ecode3 = 0 ;
16045 PyObject * obj0 = 0 ;
16046 PyObject * obj1 = 0 ;
16047 PyObject * obj2 = 0 ;
16048 char * kwnames[] = {
16049 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16050 };
16051
16052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16054 if (!SWIG_IsOK(res1)) {
16055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16056 }
16057 arg1 = reinterpret_cast< wxGrid * >(argp1);
16058 ecode2 = SWIG_AsVal_int(obj1, &val2);
16059 if (!SWIG_IsOK(ecode2)) {
16060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16061 }
16062 arg2 = static_cast< int >(val2);
16063 if (obj2) {
16064 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16065 if (!SWIG_IsOK(ecode3)) {
16066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16067 }
16068 arg3 = static_cast< bool >(val3);
16069 }
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 (arg1)->AutoSizeColumn(arg2,arg3);
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 resultobj = SWIG_Py_Void();
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj = 0;
16085 wxGrid *arg1 = (wxGrid *) 0 ;
16086 int arg2 ;
16087 bool arg3 = (bool) true ;
16088 void *argp1 = 0 ;
16089 int res1 = 0 ;
16090 int val2 ;
16091 int ecode2 = 0 ;
16092 bool val3 ;
16093 int ecode3 = 0 ;
16094 PyObject * obj0 = 0 ;
16095 PyObject * obj1 = 0 ;
16096 PyObject * obj2 = 0 ;
16097 char * kwnames[] = {
16098 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16099 };
16100
16101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16103 if (!SWIG_IsOK(res1)) {
16104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16105 }
16106 arg1 = reinterpret_cast< wxGrid * >(argp1);
16107 ecode2 = SWIG_AsVal_int(obj1, &val2);
16108 if (!SWIG_IsOK(ecode2)) {
16109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16110 }
16111 arg2 = static_cast< int >(val2);
16112 if (obj2) {
16113 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16114 if (!SWIG_IsOK(ecode3)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16116 }
16117 arg3 = static_cast< bool >(val3);
16118 }
16119 {
16120 PyThreadState* __tstate = wxPyBeginAllowThreads();
16121 (arg1)->AutoSizeRow(arg2,arg3);
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 resultobj = SWIG_Py_Void();
16126 return resultobj;
16127 fail:
16128 return NULL;
16129 }
16130
16131
16132 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16133 PyObject *resultobj = 0;
16134 wxGrid *arg1 = (wxGrid *) 0 ;
16135 bool arg2 = (bool) true ;
16136 void *argp1 = 0 ;
16137 int res1 = 0 ;
16138 bool val2 ;
16139 int ecode2 = 0 ;
16140 PyObject * obj0 = 0 ;
16141 PyObject * obj1 = 0 ;
16142 char * kwnames[] = {
16143 (char *) "self",(char *) "setAsMin", NULL
16144 };
16145
16146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16150 }
16151 arg1 = reinterpret_cast< wxGrid * >(argp1);
16152 if (obj1) {
16153 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16154 if (!SWIG_IsOK(ecode2)) {
16155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16156 }
16157 arg2 = static_cast< bool >(val2);
16158 }
16159 {
16160 PyThreadState* __tstate = wxPyBeginAllowThreads();
16161 (arg1)->AutoSizeColumns(arg2);
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 resultobj = SWIG_Py_Void();
16166 return resultobj;
16167 fail:
16168 return NULL;
16169 }
16170
16171
16172 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16173 PyObject *resultobj = 0;
16174 wxGrid *arg1 = (wxGrid *) 0 ;
16175 bool arg2 = (bool) true ;
16176 void *argp1 = 0 ;
16177 int res1 = 0 ;
16178 bool val2 ;
16179 int ecode2 = 0 ;
16180 PyObject * obj0 = 0 ;
16181 PyObject * obj1 = 0 ;
16182 char * kwnames[] = {
16183 (char *) "self",(char *) "setAsMin", NULL
16184 };
16185
16186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16190 }
16191 arg1 = reinterpret_cast< wxGrid * >(argp1);
16192 if (obj1) {
16193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16194 if (!SWIG_IsOK(ecode2)) {
16195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16196 }
16197 arg2 = static_cast< bool >(val2);
16198 }
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 (arg1)->AutoSizeRows(arg2);
16202 wxPyEndAllowThreads(__tstate);
16203 if (PyErr_Occurred()) SWIG_fail;
16204 }
16205 resultobj = SWIG_Py_Void();
16206 return resultobj;
16207 fail:
16208 return NULL;
16209 }
16210
16211
16212 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16213 PyObject *resultobj = 0;
16214 wxGrid *arg1 = (wxGrid *) 0 ;
16215 void *argp1 = 0 ;
16216 int res1 = 0 ;
16217 PyObject *swig_obj[1] ;
16218
16219 if (!args) SWIG_fail;
16220 swig_obj[0] = args;
16221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16222 if (!SWIG_IsOK(res1)) {
16223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16224 }
16225 arg1 = reinterpret_cast< wxGrid * >(argp1);
16226 {
16227 PyThreadState* __tstate = wxPyBeginAllowThreads();
16228 (arg1)->AutoSize();
16229 wxPyEndAllowThreads(__tstate);
16230 if (PyErr_Occurred()) SWIG_fail;
16231 }
16232 resultobj = SWIG_Py_Void();
16233 return resultobj;
16234 fail:
16235 return NULL;
16236 }
16237
16238
16239 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16240 PyObject *resultobj = 0;
16241 wxGrid *arg1 = (wxGrid *) 0 ;
16242 int arg2 ;
16243 void *argp1 = 0 ;
16244 int res1 = 0 ;
16245 int val2 ;
16246 int ecode2 = 0 ;
16247 PyObject * obj0 = 0 ;
16248 PyObject * obj1 = 0 ;
16249 char * kwnames[] = {
16250 (char *) "self",(char *) "row", NULL
16251 };
16252
16253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16257 }
16258 arg1 = reinterpret_cast< wxGrid * >(argp1);
16259 ecode2 = SWIG_AsVal_int(obj1, &val2);
16260 if (!SWIG_IsOK(ecode2)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16262 }
16263 arg2 = static_cast< int >(val2);
16264 {
16265 PyThreadState* __tstate = wxPyBeginAllowThreads();
16266 (arg1)->AutoSizeRowLabelSize(arg2);
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 resultobj = SWIG_Py_Void();
16271 return resultobj;
16272 fail:
16273 return NULL;
16274 }
16275
16276
16277 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj = 0;
16279 wxGrid *arg1 = (wxGrid *) 0 ;
16280 int arg2 ;
16281 void *argp1 = 0 ;
16282 int res1 = 0 ;
16283 int val2 ;
16284 int ecode2 = 0 ;
16285 PyObject * obj0 = 0 ;
16286 PyObject * obj1 = 0 ;
16287 char * kwnames[] = {
16288 (char *) "self",(char *) "col", NULL
16289 };
16290
16291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16293 if (!SWIG_IsOK(res1)) {
16294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16295 }
16296 arg1 = reinterpret_cast< wxGrid * >(argp1);
16297 ecode2 = SWIG_AsVal_int(obj1, &val2);
16298 if (!SWIG_IsOK(ecode2)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16300 }
16301 arg2 = static_cast< int >(val2);
16302 {
16303 PyThreadState* __tstate = wxPyBeginAllowThreads();
16304 (arg1)->AutoSizeColLabelSize(arg2);
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 resultobj = SWIG_Py_Void();
16309 return resultobj;
16310 fail:
16311 return NULL;
16312 }
16313
16314
16315 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16316 PyObject *resultobj = 0;
16317 wxGrid *arg1 = (wxGrid *) 0 ;
16318 int arg2 ;
16319 int arg3 ;
16320 void *argp1 = 0 ;
16321 int res1 = 0 ;
16322 int val2 ;
16323 int ecode2 = 0 ;
16324 int val3 ;
16325 int ecode3 = 0 ;
16326 PyObject * obj0 = 0 ;
16327 PyObject * obj1 = 0 ;
16328 PyObject * obj2 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "col",(char *) "width", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16337 }
16338 arg1 = reinterpret_cast< wxGrid * >(argp1);
16339 ecode2 = SWIG_AsVal_int(obj1, &val2);
16340 if (!SWIG_IsOK(ecode2)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16342 }
16343 arg2 = static_cast< int >(val2);
16344 ecode3 = SWIG_AsVal_int(obj2, &val3);
16345 if (!SWIG_IsOK(ecode3)) {
16346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16347 }
16348 arg3 = static_cast< int >(val3);
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 (arg1)->SetColMinimalWidth(arg2,arg3);
16352 wxPyEndAllowThreads(__tstate);
16353 if (PyErr_Occurred()) SWIG_fail;
16354 }
16355 resultobj = SWIG_Py_Void();
16356 return resultobj;
16357 fail:
16358 return NULL;
16359 }
16360
16361
16362 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16363 PyObject *resultobj = 0;
16364 wxGrid *arg1 = (wxGrid *) 0 ;
16365 int arg2 ;
16366 int arg3 ;
16367 void *argp1 = 0 ;
16368 int res1 = 0 ;
16369 int val2 ;
16370 int ecode2 = 0 ;
16371 int val3 ;
16372 int ecode3 = 0 ;
16373 PyObject * obj0 = 0 ;
16374 PyObject * obj1 = 0 ;
16375 PyObject * obj2 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "row",(char *) "width", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16384 }
16385 arg1 = reinterpret_cast< wxGrid * >(argp1);
16386 ecode2 = SWIG_AsVal_int(obj1, &val2);
16387 if (!SWIG_IsOK(ecode2)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16389 }
16390 arg2 = static_cast< int >(val2);
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 (arg1)->SetRowMinimalHeight(arg2,arg3);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 resultobj = SWIG_Py_Void();
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16410 PyObject *resultobj = 0;
16411 wxGrid *arg1 = (wxGrid *) 0 ;
16412 int arg2 ;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 int val2 ;
16416 int ecode2 = 0 ;
16417 PyObject * obj0 = 0 ;
16418 PyObject * obj1 = 0 ;
16419 char * kwnames[] = {
16420 (char *) "self",(char *) "width", NULL
16421 };
16422
16423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16427 }
16428 arg1 = reinterpret_cast< wxGrid * >(argp1);
16429 ecode2 = SWIG_AsVal_int(obj1, &val2);
16430 if (!SWIG_IsOK(ecode2)) {
16431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16432 }
16433 arg2 = static_cast< int >(val2);
16434 {
16435 PyThreadState* __tstate = wxPyBeginAllowThreads();
16436 (arg1)->SetColMinimalAcceptableWidth(arg2);
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 resultobj = SWIG_Py_Void();
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj = 0;
16449 wxGrid *arg1 = (wxGrid *) 0 ;
16450 int arg2 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 int val2 ;
16454 int ecode2 = 0 ;
16455 PyObject * obj0 = 0 ;
16456 PyObject * obj1 = 0 ;
16457 char * kwnames[] = {
16458 (char *) "self",(char *) "width", NULL
16459 };
16460
16461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16463 if (!SWIG_IsOK(res1)) {
16464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16465 }
16466 arg1 = reinterpret_cast< wxGrid * >(argp1);
16467 ecode2 = SWIG_AsVal_int(obj1, &val2);
16468 if (!SWIG_IsOK(ecode2)) {
16469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16470 }
16471 arg2 = static_cast< int >(val2);
16472 {
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16475 wxPyEndAllowThreads(__tstate);
16476 if (PyErr_Occurred()) SWIG_fail;
16477 }
16478 resultobj = SWIG_Py_Void();
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16486 PyObject *resultobj = 0;
16487 wxGrid *arg1 = (wxGrid *) 0 ;
16488 int result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 PyObject *swig_obj[1] ;
16492
16493 if (!args) SWIG_fail;
16494 swig_obj[0] = args;
16495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16496 if (!SWIG_IsOK(res1)) {
16497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16498 }
16499 arg1 = reinterpret_cast< wxGrid * >(argp1);
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 resultobj = SWIG_From_int(static_cast< int >(result));
16507 return resultobj;
16508 fail:
16509 return NULL;
16510 }
16511
16512
16513 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16514 PyObject *resultobj = 0;
16515 wxGrid *arg1 = (wxGrid *) 0 ;
16516 int result;
16517 void *argp1 = 0 ;
16518 int res1 = 0 ;
16519 PyObject *swig_obj[1] ;
16520
16521 if (!args) SWIG_fail;
16522 swig_obj[0] = args;
16523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16524 if (!SWIG_IsOK(res1)) {
16525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16526 }
16527 arg1 = reinterpret_cast< wxGrid * >(argp1);
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16531 wxPyEndAllowThreads(__tstate);
16532 if (PyErr_Occurred()) SWIG_fail;
16533 }
16534 resultobj = SWIG_From_int(static_cast< int >(result));
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxGrid *arg1 = (wxGrid *) 0 ;
16544 wxColour *arg2 = 0 ;
16545 void *argp1 = 0 ;
16546 int res1 = 0 ;
16547 wxColour temp2 ;
16548 PyObject * obj0 = 0 ;
16549 PyObject * obj1 = 0 ;
16550 char * kwnames[] = {
16551 (char *) "self",(char *)"arg2", NULL
16552 };
16553
16554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16556 if (!SWIG_IsOK(res1)) {
16557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16558 }
16559 arg1 = reinterpret_cast< wxGrid * >(argp1);
16560 {
16561 arg2 = &temp2;
16562 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16563 }
16564 {
16565 PyThreadState* __tstate = wxPyBeginAllowThreads();
16566 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16567 wxPyEndAllowThreads(__tstate);
16568 if (PyErr_Occurred()) SWIG_fail;
16569 }
16570 resultobj = SWIG_Py_Void();
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj = 0;
16579 wxGrid *arg1 = (wxGrid *) 0 ;
16580 int arg2 ;
16581 int arg3 ;
16582 wxColour *arg4 = 0 ;
16583 void *argp1 = 0 ;
16584 int res1 = 0 ;
16585 int val2 ;
16586 int ecode2 = 0 ;
16587 int val3 ;
16588 int ecode3 = 0 ;
16589 wxColour temp4 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 PyObject * obj3 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16602 }
16603 arg1 = reinterpret_cast< wxGrid * >(argp1);
16604 ecode2 = SWIG_AsVal_int(obj1, &val2);
16605 if (!SWIG_IsOK(ecode2)) {
16606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16607 }
16608 arg2 = static_cast< int >(val2);
16609 ecode3 = SWIG_AsVal_int(obj2, &val3);
16610 if (!SWIG_IsOK(ecode3)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16612 }
16613 arg3 = static_cast< int >(val3);
16614 {
16615 arg4 = &temp4;
16616 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16617 }
16618 {
16619 PyThreadState* __tstate = wxPyBeginAllowThreads();
16620 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 resultobj = SWIG_Py_Void();
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj = 0;
16633 wxGrid *arg1 = (wxGrid *) 0 ;
16634 wxColour *arg2 = 0 ;
16635 void *argp1 = 0 ;
16636 int res1 = 0 ;
16637 wxColour temp2 ;
16638 PyObject * obj0 = 0 ;
16639 PyObject * obj1 = 0 ;
16640 char * kwnames[] = {
16641 (char *) "self",(char *)"arg2", NULL
16642 };
16643
16644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16646 if (!SWIG_IsOK(res1)) {
16647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16648 }
16649 arg1 = reinterpret_cast< wxGrid * >(argp1);
16650 {
16651 arg2 = &temp2;
16652 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16653 }
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16657 wxPyEndAllowThreads(__tstate);
16658 if (PyErr_Occurred()) SWIG_fail;
16659 }
16660 resultobj = SWIG_Py_Void();
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16668 PyObject *resultobj = 0;
16669 wxGrid *arg1 = (wxGrid *) 0 ;
16670 int arg2 ;
16671 int arg3 ;
16672 wxColour *arg4 = 0 ;
16673 void *argp1 = 0 ;
16674 int res1 = 0 ;
16675 int val2 ;
16676 int ecode2 = 0 ;
16677 int val3 ;
16678 int ecode3 = 0 ;
16679 wxColour temp4 ;
16680 PyObject * obj0 = 0 ;
16681 PyObject * obj1 = 0 ;
16682 PyObject * obj2 = 0 ;
16683 PyObject * obj3 = 0 ;
16684 char * kwnames[] = {
16685 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16686 };
16687
16688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16690 if (!SWIG_IsOK(res1)) {
16691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16692 }
16693 arg1 = reinterpret_cast< wxGrid * >(argp1);
16694 ecode2 = SWIG_AsVal_int(obj1, &val2);
16695 if (!SWIG_IsOK(ecode2)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16697 }
16698 arg2 = static_cast< int >(val2);
16699 ecode3 = SWIG_AsVal_int(obj2, &val3);
16700 if (!SWIG_IsOK(ecode3)) {
16701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16702 }
16703 arg3 = static_cast< int >(val3);
16704 {
16705 arg4 = &temp4;
16706 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16707 }
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 resultobj = SWIG_Py_Void();
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj = 0;
16723 wxGrid *arg1 = (wxGrid *) 0 ;
16724 wxFont *arg2 = 0 ;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 void *argp2 = 0 ;
16728 int res2 = 0 ;
16729 PyObject * obj0 = 0 ;
16730 PyObject * obj1 = 0 ;
16731 char * kwnames[] = {
16732 (char *) "self",(char *)"arg2", NULL
16733 };
16734
16735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16739 }
16740 arg1 = reinterpret_cast< wxGrid * >(argp1);
16741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16742 if (!SWIG_IsOK(res2)) {
16743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16744 }
16745 if (!argp2) {
16746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16747 }
16748 arg2 = reinterpret_cast< wxFont * >(argp2);
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 resultobj = SWIG_Py_Void();
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj = 0;
16764 wxGrid *arg1 = (wxGrid *) 0 ;
16765 int arg2 ;
16766 int arg3 ;
16767 wxFont *arg4 = 0 ;
16768 void *argp1 = 0 ;
16769 int res1 = 0 ;
16770 int val2 ;
16771 int ecode2 = 0 ;
16772 int val3 ;
16773 int ecode3 = 0 ;
16774 void *argp4 = 0 ;
16775 int res4 = 0 ;
16776 PyObject * obj0 = 0 ;
16777 PyObject * obj1 = 0 ;
16778 PyObject * obj2 = 0 ;
16779 PyObject * obj3 = 0 ;
16780 char * kwnames[] = {
16781 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16782 };
16783
16784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16786 if (!SWIG_IsOK(res1)) {
16787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16788 }
16789 arg1 = reinterpret_cast< wxGrid * >(argp1);
16790 ecode2 = SWIG_AsVal_int(obj1, &val2);
16791 if (!SWIG_IsOK(ecode2)) {
16792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16793 }
16794 arg2 = static_cast< int >(val2);
16795 ecode3 = SWIG_AsVal_int(obj2, &val3);
16796 if (!SWIG_IsOK(ecode3)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16798 }
16799 arg3 = static_cast< int >(val3);
16800 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16801 if (!SWIG_IsOK(res4)) {
16802 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16803 }
16804 if (!argp4) {
16805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16806 }
16807 arg4 = reinterpret_cast< wxFont * >(argp4);
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_Py_Void();
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16822 PyObject *resultobj = 0;
16823 wxGrid *arg1 = (wxGrid *) 0 ;
16824 int arg2 ;
16825 int arg3 ;
16826 void *argp1 = 0 ;
16827 int res1 = 0 ;
16828 int val2 ;
16829 int ecode2 = 0 ;
16830 int val3 ;
16831 int ecode3 = 0 ;
16832 PyObject * obj0 = 0 ;
16833 PyObject * obj1 = 0 ;
16834 PyObject * obj2 = 0 ;
16835 char * kwnames[] = {
16836 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16837 };
16838
16839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16841 if (!SWIG_IsOK(res1)) {
16842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16843 }
16844 arg1 = reinterpret_cast< wxGrid * >(argp1);
16845 ecode2 = SWIG_AsVal_int(obj1, &val2);
16846 if (!SWIG_IsOK(ecode2)) {
16847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16848 }
16849 arg2 = static_cast< int >(val2);
16850 ecode3 = SWIG_AsVal_int(obj2, &val3);
16851 if (!SWIG_IsOK(ecode3)) {
16852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16853 }
16854 arg3 = static_cast< int >(val3);
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 resultobj = SWIG_Py_Void();
16862 return resultobj;
16863 fail:
16864 return NULL;
16865 }
16866
16867
16868 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj = 0;
16870 wxGrid *arg1 = (wxGrid *) 0 ;
16871 int arg2 ;
16872 int arg3 ;
16873 int arg4 ;
16874 int arg5 ;
16875 void *argp1 = 0 ;
16876 int res1 = 0 ;
16877 int val2 ;
16878 int ecode2 = 0 ;
16879 int val3 ;
16880 int ecode3 = 0 ;
16881 int val4 ;
16882 int ecode4 = 0 ;
16883 int val5 ;
16884 int ecode5 = 0 ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 PyObject * obj2 = 0 ;
16888 PyObject * obj3 = 0 ;
16889 PyObject * obj4 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16898 }
16899 arg1 = reinterpret_cast< wxGrid * >(argp1);
16900 ecode2 = SWIG_AsVal_int(obj1, &val2);
16901 if (!SWIG_IsOK(ecode2)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16903 }
16904 arg2 = static_cast< int >(val2);
16905 ecode3 = SWIG_AsVal_int(obj2, &val3);
16906 if (!SWIG_IsOK(ecode3)) {
16907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16908 }
16909 arg3 = static_cast< int >(val3);
16910 ecode4 = SWIG_AsVal_int(obj3, &val4);
16911 if (!SWIG_IsOK(ecode4)) {
16912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16913 }
16914 arg4 = static_cast< int >(val4);
16915 ecode5 = SWIG_AsVal_int(obj4, &val5);
16916 if (!SWIG_IsOK(ecode5)) {
16917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16918 }
16919 arg5 = static_cast< int >(val5);
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_Py_Void();
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16934 PyObject *resultobj = 0;
16935 wxGrid *arg1 = (wxGrid *) 0 ;
16936 bool arg2 ;
16937 void *argp1 = 0 ;
16938 int res1 = 0 ;
16939 bool val2 ;
16940 int ecode2 = 0 ;
16941 PyObject * obj0 = 0 ;
16942 PyObject * obj1 = 0 ;
16943 char * kwnames[] = {
16944 (char *) "self",(char *) "allow", NULL
16945 };
16946
16947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16949 if (!SWIG_IsOK(res1)) {
16950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16951 }
16952 arg1 = reinterpret_cast< wxGrid * >(argp1);
16953 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16954 if (!SWIG_IsOK(ecode2)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16956 }
16957 arg2 = static_cast< bool >(val2);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 (arg1)->SetDefaultCellOverflow(arg2);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_Py_Void();
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj = 0;
16973 wxGrid *arg1 = (wxGrid *) 0 ;
16974 int arg2 ;
16975 int arg3 ;
16976 bool arg4 ;
16977 void *argp1 = 0 ;
16978 int res1 = 0 ;
16979 int val2 ;
16980 int ecode2 = 0 ;
16981 int val3 ;
16982 int ecode3 = 0 ;
16983 bool val4 ;
16984 int ecode4 = 0 ;
16985 PyObject * obj0 = 0 ;
16986 PyObject * obj1 = 0 ;
16987 PyObject * obj2 = 0 ;
16988 PyObject * obj3 = 0 ;
16989 char * kwnames[] = {
16990 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16991 };
16992
16993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16997 }
16998 arg1 = reinterpret_cast< wxGrid * >(argp1);
16999 ecode2 = SWIG_AsVal_int(obj1, &val2);
17000 if (!SWIG_IsOK(ecode2)) {
17001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17002 }
17003 arg2 = static_cast< int >(val2);
17004 ecode3 = SWIG_AsVal_int(obj2, &val3);
17005 if (!SWIG_IsOK(ecode3)) {
17006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17007 }
17008 arg3 = static_cast< int >(val3);
17009 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17010 if (!SWIG_IsOK(ecode4)) {
17011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17012 }
17013 arg4 = static_cast< bool >(val4);
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_Py_Void();
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxGrid *arg1 = (wxGrid *) 0 ;
17030 int arg2 ;
17031 int arg3 ;
17032 int arg4 ;
17033 int arg5 ;
17034 void *argp1 = 0 ;
17035 int res1 = 0 ;
17036 int val2 ;
17037 int ecode2 = 0 ;
17038 int val3 ;
17039 int ecode3 = 0 ;
17040 int val4 ;
17041 int ecode4 = 0 ;
17042 int val5 ;
17043 int ecode5 = 0 ;
17044 PyObject * obj0 = 0 ;
17045 PyObject * obj1 = 0 ;
17046 PyObject * obj2 = 0 ;
17047 PyObject * obj3 = 0 ;
17048 PyObject * obj4 = 0 ;
17049 char * kwnames[] = {
17050 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17051 };
17052
17053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17055 if (!SWIG_IsOK(res1)) {
17056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17057 }
17058 arg1 = reinterpret_cast< wxGrid * >(argp1);
17059 ecode2 = SWIG_AsVal_int(obj1, &val2);
17060 if (!SWIG_IsOK(ecode2)) {
17061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17062 }
17063 arg2 = static_cast< int >(val2);
17064 ecode3 = SWIG_AsVal_int(obj2, &val3);
17065 if (!SWIG_IsOK(ecode3)) {
17066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17067 }
17068 arg3 = static_cast< int >(val3);
17069 ecode4 = SWIG_AsVal_int(obj3, &val4);
17070 if (!SWIG_IsOK(ecode4)) {
17071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17072 }
17073 arg4 = static_cast< int >(val4);
17074 ecode5 = SWIG_AsVal_int(obj4, &val5);
17075 if (!SWIG_IsOK(ecode5)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17077 }
17078 arg5 = static_cast< int >(val5);
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 resultobj = SWIG_Py_Void();
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj = 0;
17094 wxGrid *arg1 = (wxGrid *) 0 ;
17095 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 void *argp2 = 0 ;
17099 int res2 = 0 ;
17100 PyObject * obj0 = 0 ;
17101 PyObject * obj1 = 0 ;
17102 char * kwnames[] = {
17103 (char *) "self",(char *) "renderer", NULL
17104 };
17105
17106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17108 if (!SWIG_IsOK(res1)) {
17109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17110 }
17111 arg1 = reinterpret_cast< wxGrid * >(argp1);
17112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17113 if (!SWIG_IsOK(res2)) {
17114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17115 }
17116 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 (arg1)->SetDefaultRenderer(arg2);
17120 wxPyEndAllowThreads(__tstate);
17121 if (PyErr_Occurred()) SWIG_fail;
17122 }
17123 resultobj = SWIG_Py_Void();
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj = 0;
17132 wxGrid *arg1 = (wxGrid *) 0 ;
17133 int arg2 ;
17134 int arg3 ;
17135 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17136 void *argp1 = 0 ;
17137 int res1 = 0 ;
17138 int val2 ;
17139 int ecode2 = 0 ;
17140 int val3 ;
17141 int ecode3 = 0 ;
17142 void *argp4 = 0 ;
17143 int res4 = 0 ;
17144 PyObject * obj0 = 0 ;
17145 PyObject * obj1 = 0 ;
17146 PyObject * obj2 = 0 ;
17147 PyObject * obj3 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17156 }
17157 arg1 = reinterpret_cast< wxGrid * >(argp1);
17158 ecode2 = SWIG_AsVal_int(obj1, &val2);
17159 if (!SWIG_IsOK(ecode2)) {
17160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17161 }
17162 arg2 = static_cast< int >(val2);
17163 ecode3 = SWIG_AsVal_int(obj2, &val3);
17164 if (!SWIG_IsOK(ecode3)) {
17165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17166 }
17167 arg3 = static_cast< int >(val3);
17168 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17169 if (!SWIG_IsOK(res4)) {
17170 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17171 }
17172 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = SWIG_Py_Void();
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17187 PyObject *resultobj = 0;
17188 wxGrid *arg1 = (wxGrid *) 0 ;
17189 wxGridCellRenderer *result = 0 ;
17190 void *argp1 = 0 ;
17191 int res1 = 0 ;
17192 PyObject *swig_obj[1] ;
17193
17194 if (!args) SWIG_fail;
17195 swig_obj[0] = args;
17196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17197 if (!SWIG_IsOK(res1)) {
17198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17199 }
17200 arg1 = reinterpret_cast< wxGrid * >(argp1);
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 {
17208 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17209 }
17210 return resultobj;
17211 fail:
17212 return NULL;
17213 }
17214
17215
17216 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17217 PyObject *resultobj = 0;
17218 wxGrid *arg1 = (wxGrid *) 0 ;
17219 int arg2 ;
17220 int arg3 ;
17221 wxGridCellRenderer *result = 0 ;
17222 void *argp1 = 0 ;
17223 int res1 = 0 ;
17224 int val2 ;
17225 int ecode2 = 0 ;
17226 int val3 ;
17227 int ecode3 = 0 ;
17228 PyObject * obj0 = 0 ;
17229 PyObject * obj1 = 0 ;
17230 PyObject * obj2 = 0 ;
17231 char * kwnames[] = {
17232 (char *) "self",(char *) "row",(char *) "col", NULL
17233 };
17234
17235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17237 if (!SWIG_IsOK(res1)) {
17238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17239 }
17240 arg1 = reinterpret_cast< wxGrid * >(argp1);
17241 ecode2 = SWIG_AsVal_int(obj1, &val2);
17242 if (!SWIG_IsOK(ecode2)) {
17243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17244 }
17245 arg2 = static_cast< int >(val2);
17246 ecode3 = SWIG_AsVal_int(obj2, &val3);
17247 if (!SWIG_IsOK(ecode3)) {
17248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17249 }
17250 arg3 = static_cast< int >(val3);
17251 {
17252 PyThreadState* __tstate = wxPyBeginAllowThreads();
17253 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj = 0;
17268 wxGrid *arg1 = (wxGrid *) 0 ;
17269 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17270 void *argp1 = 0 ;
17271 int res1 = 0 ;
17272 void *argp2 = 0 ;
17273 int res2 = 0 ;
17274 PyObject * obj0 = 0 ;
17275 PyObject * obj1 = 0 ;
17276 char * kwnames[] = {
17277 (char *) "self",(char *) "editor", NULL
17278 };
17279
17280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17282 if (!SWIG_IsOK(res1)) {
17283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17284 }
17285 arg1 = reinterpret_cast< wxGrid * >(argp1);
17286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17287 if (!SWIG_IsOK(res2)) {
17288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17289 }
17290 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17291 {
17292 PyThreadState* __tstate = wxPyBeginAllowThreads();
17293 (arg1)->SetDefaultEditor(arg2);
17294 wxPyEndAllowThreads(__tstate);
17295 if (PyErr_Occurred()) SWIG_fail;
17296 }
17297 resultobj = SWIG_Py_Void();
17298 return resultobj;
17299 fail:
17300 return NULL;
17301 }
17302
17303
17304 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17305 PyObject *resultobj = 0;
17306 wxGrid *arg1 = (wxGrid *) 0 ;
17307 int arg2 ;
17308 int arg3 ;
17309 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17310 void *argp1 = 0 ;
17311 int res1 = 0 ;
17312 int val2 ;
17313 int ecode2 = 0 ;
17314 int val3 ;
17315 int ecode3 = 0 ;
17316 void *argp4 = 0 ;
17317 int res4 = 0 ;
17318 PyObject * obj0 = 0 ;
17319 PyObject * obj1 = 0 ;
17320 PyObject * obj2 = 0 ;
17321 PyObject * obj3 = 0 ;
17322 char * kwnames[] = {
17323 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17324 };
17325
17326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17328 if (!SWIG_IsOK(res1)) {
17329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17330 }
17331 arg1 = reinterpret_cast< wxGrid * >(argp1);
17332 ecode2 = SWIG_AsVal_int(obj1, &val2);
17333 if (!SWIG_IsOK(ecode2)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17335 }
17336 arg2 = static_cast< int >(val2);
17337 ecode3 = SWIG_AsVal_int(obj2, &val3);
17338 if (!SWIG_IsOK(ecode3)) {
17339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17340 }
17341 arg3 = static_cast< int >(val3);
17342 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17343 if (!SWIG_IsOK(res4)) {
17344 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17345 }
17346 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 (arg1)->SetCellEditor(arg2,arg3,arg4);
17350 wxPyEndAllowThreads(__tstate);
17351 if (PyErr_Occurred()) SWIG_fail;
17352 }
17353 resultobj = SWIG_Py_Void();
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17361 PyObject *resultobj = 0;
17362 wxGrid *arg1 = (wxGrid *) 0 ;
17363 wxGridCellEditor *result = 0 ;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 PyObject *swig_obj[1] ;
17367
17368 if (!args) SWIG_fail;
17369 swig_obj[0] = args;
17370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17371 if (!SWIG_IsOK(res1)) {
17372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17373 }
17374 arg1 = reinterpret_cast< wxGrid * >(argp1);
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17383 }
17384 return resultobj;
17385 fail:
17386 return NULL;
17387 }
17388
17389
17390 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj = 0;
17392 wxGrid *arg1 = (wxGrid *) 0 ;
17393 int arg2 ;
17394 int arg3 ;
17395 wxGridCellEditor *result = 0 ;
17396 void *argp1 = 0 ;
17397 int res1 = 0 ;
17398 int val2 ;
17399 int ecode2 = 0 ;
17400 int val3 ;
17401 int ecode3 = 0 ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 char * kwnames[] = {
17406 (char *) "self",(char *) "row",(char *) "col", NULL
17407 };
17408
17409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17411 if (!SWIG_IsOK(res1)) {
17412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17413 }
17414 arg1 = reinterpret_cast< wxGrid * >(argp1);
17415 ecode2 = SWIG_AsVal_int(obj1, &val2);
17416 if (!SWIG_IsOK(ecode2)) {
17417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17418 }
17419 arg2 = static_cast< int >(val2);
17420 ecode3 = SWIG_AsVal_int(obj2, &val3);
17421 if (!SWIG_IsOK(ecode3)) {
17422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17423 }
17424 arg3 = static_cast< int >(val3);
17425 {
17426 PyThreadState* __tstate = wxPyBeginAllowThreads();
17427 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj = 0;
17442 wxGrid *arg1 = (wxGrid *) 0 ;
17443 int arg2 ;
17444 int arg3 ;
17445 wxString result;
17446 void *argp1 = 0 ;
17447 int res1 = 0 ;
17448 int val2 ;
17449 int ecode2 = 0 ;
17450 int val3 ;
17451 int ecode3 = 0 ;
17452 PyObject * obj0 = 0 ;
17453 PyObject * obj1 = 0 ;
17454 PyObject * obj2 = 0 ;
17455 char * kwnames[] = {
17456 (char *) "self",(char *) "row",(char *) "col", NULL
17457 };
17458
17459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17461 if (!SWIG_IsOK(res1)) {
17462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17463 }
17464 arg1 = reinterpret_cast< wxGrid * >(argp1);
17465 ecode2 = SWIG_AsVal_int(obj1, &val2);
17466 if (!SWIG_IsOK(ecode2)) {
17467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17468 }
17469 arg2 = static_cast< int >(val2);
17470 ecode3 = SWIG_AsVal_int(obj2, &val3);
17471 if (!SWIG_IsOK(ecode3)) {
17472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17473 }
17474 arg3 = static_cast< int >(val3);
17475 {
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 result = (arg1)->GetCellValue(arg2,arg3);
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 {
17482 #if wxUSE_UNICODE
17483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17484 #else
17485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17486 #endif
17487 }
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj = 0;
17496 wxGrid *arg1 = (wxGrid *) 0 ;
17497 int arg2 ;
17498 int arg3 ;
17499 wxString *arg4 = 0 ;
17500 void *argp1 = 0 ;
17501 int res1 = 0 ;
17502 int val2 ;
17503 int ecode2 = 0 ;
17504 int val3 ;
17505 int ecode3 = 0 ;
17506 bool temp4 = false ;
17507 PyObject * obj0 = 0 ;
17508 PyObject * obj1 = 0 ;
17509 PyObject * obj2 = 0 ;
17510 PyObject * obj3 = 0 ;
17511 char * kwnames[] = {
17512 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17513 };
17514
17515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17517 if (!SWIG_IsOK(res1)) {
17518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17519 }
17520 arg1 = reinterpret_cast< wxGrid * >(argp1);
17521 ecode2 = SWIG_AsVal_int(obj1, &val2);
17522 if (!SWIG_IsOK(ecode2)) {
17523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17524 }
17525 arg2 = static_cast< int >(val2);
17526 ecode3 = SWIG_AsVal_int(obj2, &val3);
17527 if (!SWIG_IsOK(ecode3)) {
17528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17529 }
17530 arg3 = static_cast< int >(val3);
17531 {
17532 arg4 = wxString_in_helper(obj3);
17533 if (arg4 == NULL) SWIG_fail;
17534 temp4 = true;
17535 }
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_Py_Void();
17543 {
17544 if (temp4)
17545 delete arg4;
17546 }
17547 return resultobj;
17548 fail:
17549 {
17550 if (temp4)
17551 delete arg4;
17552 }
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj = 0;
17559 wxGrid *arg1 = (wxGrid *) 0 ;
17560 int arg2 ;
17561 int arg3 ;
17562 bool result;
17563 void *argp1 = 0 ;
17564 int res1 = 0 ;
17565 int val2 ;
17566 int ecode2 = 0 ;
17567 int val3 ;
17568 int ecode3 = 0 ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char * kwnames[] = {
17573 (char *) "self",(char *) "row",(char *) "col", NULL
17574 };
17575
17576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17578 if (!SWIG_IsOK(res1)) {
17579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17580 }
17581 arg1 = reinterpret_cast< wxGrid * >(argp1);
17582 ecode2 = SWIG_AsVal_int(obj1, &val2);
17583 if (!SWIG_IsOK(ecode2)) {
17584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17585 }
17586 arg2 = static_cast< int >(val2);
17587 ecode3 = SWIG_AsVal_int(obj2, &val3);
17588 if (!SWIG_IsOK(ecode3)) {
17589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17590 }
17591 arg3 = static_cast< int >(val3);
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 {
17599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17600 }
17601 return resultobj;
17602 fail:
17603 return NULL;
17604 }
17605
17606
17607 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17608 PyObject *resultobj = 0;
17609 wxGrid *arg1 = (wxGrid *) 0 ;
17610 int arg2 ;
17611 int arg3 ;
17612 bool arg4 = (bool) true ;
17613 void *argp1 = 0 ;
17614 int res1 = 0 ;
17615 int val2 ;
17616 int ecode2 = 0 ;
17617 int val3 ;
17618 int ecode3 = 0 ;
17619 bool val4 ;
17620 int ecode4 = 0 ;
17621 PyObject * obj0 = 0 ;
17622 PyObject * obj1 = 0 ;
17623 PyObject * obj2 = 0 ;
17624 PyObject * obj3 = 0 ;
17625 char * kwnames[] = {
17626 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17627 };
17628
17629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17633 }
17634 arg1 = reinterpret_cast< wxGrid * >(argp1);
17635 ecode2 = SWIG_AsVal_int(obj1, &val2);
17636 if (!SWIG_IsOK(ecode2)) {
17637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17638 }
17639 arg2 = static_cast< int >(val2);
17640 ecode3 = SWIG_AsVal_int(obj2, &val3);
17641 if (!SWIG_IsOK(ecode3)) {
17642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17643 }
17644 arg3 = static_cast< int >(val3);
17645 if (obj3) {
17646 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17647 if (!SWIG_IsOK(ecode4)) {
17648 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17649 }
17650 arg4 = static_cast< bool >(val4);
17651 }
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 (arg1)->SetReadOnly(arg2,arg3,arg4);
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 resultobj = SWIG_Py_Void();
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj = 0;
17667 wxGrid *arg1 = (wxGrid *) 0 ;
17668 int arg2 ;
17669 bool arg3 = (bool) false ;
17670 void *argp1 = 0 ;
17671 int res1 = 0 ;
17672 int val2 ;
17673 int ecode2 = 0 ;
17674 bool val3 ;
17675 int ecode3 = 0 ;
17676 PyObject * obj0 = 0 ;
17677 PyObject * obj1 = 0 ;
17678 PyObject * obj2 = 0 ;
17679 char * kwnames[] = {
17680 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17681 };
17682
17683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17685 if (!SWIG_IsOK(res1)) {
17686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17687 }
17688 arg1 = reinterpret_cast< wxGrid * >(argp1);
17689 ecode2 = SWIG_AsVal_int(obj1, &val2);
17690 if (!SWIG_IsOK(ecode2)) {
17691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17692 }
17693 arg2 = static_cast< int >(val2);
17694 if (obj2) {
17695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17696 if (!SWIG_IsOK(ecode3)) {
17697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17698 }
17699 arg3 = static_cast< bool >(val3);
17700 }
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 (arg1)->SelectRow(arg2,arg3);
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 resultobj = SWIG_Py_Void();
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj = 0;
17716 wxGrid *arg1 = (wxGrid *) 0 ;
17717 int arg2 ;
17718 bool arg3 = (bool) false ;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 int val2 ;
17722 int ecode2 = 0 ;
17723 bool val3 ;
17724 int ecode3 = 0 ;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 PyObject * obj2 = 0 ;
17728 char * kwnames[] = {
17729 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17730 };
17731
17732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17736 }
17737 arg1 = reinterpret_cast< wxGrid * >(argp1);
17738 ecode2 = SWIG_AsVal_int(obj1, &val2);
17739 if (!SWIG_IsOK(ecode2)) {
17740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17741 }
17742 arg2 = static_cast< int >(val2);
17743 if (obj2) {
17744 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17745 if (!SWIG_IsOK(ecode3)) {
17746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17747 }
17748 arg3 = static_cast< bool >(val3);
17749 }
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 (arg1)->SelectCol(arg2,arg3);
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 resultobj = SWIG_Py_Void();
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj = 0;
17765 wxGrid *arg1 = (wxGrid *) 0 ;
17766 int arg2 ;
17767 int arg3 ;
17768 int arg4 ;
17769 int arg5 ;
17770 bool arg6 = (bool) false ;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 int val2 ;
17774 int ecode2 = 0 ;
17775 int val3 ;
17776 int ecode3 = 0 ;
17777 int val4 ;
17778 int ecode4 = 0 ;
17779 int val5 ;
17780 int ecode5 = 0 ;
17781 bool val6 ;
17782 int ecode6 = 0 ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 PyObject * obj2 = 0 ;
17786 PyObject * obj3 = 0 ;
17787 PyObject * obj4 = 0 ;
17788 PyObject * obj5 = 0 ;
17789 char * kwnames[] = {
17790 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17791 };
17792
17793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17795 if (!SWIG_IsOK(res1)) {
17796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17797 }
17798 arg1 = reinterpret_cast< wxGrid * >(argp1);
17799 ecode2 = SWIG_AsVal_int(obj1, &val2);
17800 if (!SWIG_IsOK(ecode2)) {
17801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17802 }
17803 arg2 = static_cast< int >(val2);
17804 ecode3 = SWIG_AsVal_int(obj2, &val3);
17805 if (!SWIG_IsOK(ecode3)) {
17806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17807 }
17808 arg3 = static_cast< int >(val3);
17809 ecode4 = SWIG_AsVal_int(obj3, &val4);
17810 if (!SWIG_IsOK(ecode4)) {
17811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17812 }
17813 arg4 = static_cast< int >(val4);
17814 ecode5 = SWIG_AsVal_int(obj4, &val5);
17815 if (!SWIG_IsOK(ecode5)) {
17816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17817 }
17818 arg5 = static_cast< int >(val5);
17819 if (obj5) {
17820 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17821 if (!SWIG_IsOK(ecode6)) {
17822 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17823 }
17824 arg6 = static_cast< bool >(val6);
17825 }
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 resultobj = SWIG_Py_Void();
17833 return resultobj;
17834 fail:
17835 return NULL;
17836 }
17837
17838
17839 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17840 PyObject *resultobj = 0;
17841 wxGrid *arg1 = (wxGrid *) 0 ;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 PyObject *swig_obj[1] ;
17845
17846 if (!args) SWIG_fail;
17847 swig_obj[0] = args;
17848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17849 if (!SWIG_IsOK(res1)) {
17850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17851 }
17852 arg1 = reinterpret_cast< wxGrid * >(argp1);
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 (arg1)->SelectAll();
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 resultobj = SWIG_Py_Void();
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17867 PyObject *resultobj = 0;
17868 wxGrid *arg1 = (wxGrid *) 0 ;
17869 bool result;
17870 void *argp1 = 0 ;
17871 int res1 = 0 ;
17872 PyObject *swig_obj[1] ;
17873
17874 if (!args) SWIG_fail;
17875 swig_obj[0] = args;
17876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17877 if (!SWIG_IsOK(res1)) {
17878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17879 }
17880 arg1 = reinterpret_cast< wxGrid * >(argp1);
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)(arg1)->IsSelection();
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 {
17888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17889 }
17890 return resultobj;
17891 fail:
17892 return NULL;
17893 }
17894
17895
17896 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17897 PyObject *resultobj = 0;
17898 wxGrid *arg1 = (wxGrid *) 0 ;
17899 void *argp1 = 0 ;
17900 int res1 = 0 ;
17901 PyObject *swig_obj[1] ;
17902
17903 if (!args) SWIG_fail;
17904 swig_obj[0] = args;
17905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17906 if (!SWIG_IsOK(res1)) {
17907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17908 }
17909 arg1 = reinterpret_cast< wxGrid * >(argp1);
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 (arg1)->ClearSelection();
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 resultobj = SWIG_Py_Void();
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj = 0;
17925 wxGrid *arg1 = (wxGrid *) 0 ;
17926 int arg2 ;
17927 int arg3 ;
17928 bool result;
17929 void *argp1 = 0 ;
17930 int res1 = 0 ;
17931 int val2 ;
17932 int ecode2 = 0 ;
17933 int val3 ;
17934 int ecode3 = 0 ;
17935 PyObject * obj0 = 0 ;
17936 PyObject * obj1 = 0 ;
17937 PyObject * obj2 = 0 ;
17938 char * kwnames[] = {
17939 (char *) "self",(char *) "row",(char *) "col", NULL
17940 };
17941
17942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17946 }
17947 arg1 = reinterpret_cast< wxGrid * >(argp1);
17948 ecode2 = SWIG_AsVal_int(obj1, &val2);
17949 if (!SWIG_IsOK(ecode2)) {
17950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17951 }
17952 arg2 = static_cast< int >(val2);
17953 ecode3 = SWIG_AsVal_int(obj2, &val3);
17954 if (!SWIG_IsOK(ecode3)) {
17955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17956 }
17957 arg3 = static_cast< int >(val3);
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17961 wxPyEndAllowThreads(__tstate);
17962 if (PyErr_Occurred()) SWIG_fail;
17963 }
17964 {
17965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17966 }
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17974 PyObject *resultobj = 0;
17975 wxGrid *arg1 = (wxGrid *) 0 ;
17976 wxGridCellCoordsArray result;
17977 void *argp1 = 0 ;
17978 int res1 = 0 ;
17979 PyObject *swig_obj[1] ;
17980
17981 if (!args) SWIG_fail;
17982 swig_obj[0] = args;
17983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17984 if (!SWIG_IsOK(res1)) {
17985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17986 }
17987 arg1 = reinterpret_cast< wxGrid * >(argp1);
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 result = ((wxGrid const *)arg1)->GetSelectedCells();
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 {
17995 resultobj = wxGridCellCoordsArray_helper(result);
17996 }
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18004 PyObject *resultobj = 0;
18005 wxGrid *arg1 = (wxGrid *) 0 ;
18006 wxGridCellCoordsArray result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 PyObject *swig_obj[1] ;
18010
18011 if (!args) SWIG_fail;
18012 swig_obj[0] = args;
18013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18014 if (!SWIG_IsOK(res1)) {
18015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18016 }
18017 arg1 = reinterpret_cast< wxGrid * >(argp1);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = wxGridCellCoordsArray_helper(result);
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18034 PyObject *resultobj = 0;
18035 wxGrid *arg1 = (wxGrid *) 0 ;
18036 wxGridCellCoordsArray result;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 PyObject *swig_obj[1] ;
18040
18041 if (!args) SWIG_fail;
18042 swig_obj[0] = args;
18043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18044 if (!SWIG_IsOK(res1)) {
18045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18046 }
18047 arg1 = reinterpret_cast< wxGrid * >(argp1);
18048 {
18049 PyThreadState* __tstate = wxPyBeginAllowThreads();
18050 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18051 wxPyEndAllowThreads(__tstate);
18052 if (PyErr_Occurred()) SWIG_fail;
18053 }
18054 {
18055 resultobj = wxGridCellCoordsArray_helper(result);
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *resultobj = 0;
18065 wxGrid *arg1 = (wxGrid *) 0 ;
18066 wxArrayInt result;
18067 void *argp1 = 0 ;
18068 int res1 = 0 ;
18069 PyObject *swig_obj[1] ;
18070
18071 if (!args) SWIG_fail;
18072 swig_obj[0] = args;
18073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18074 if (!SWIG_IsOK(res1)) {
18075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18076 }
18077 arg1 = reinterpret_cast< wxGrid * >(argp1);
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = ((wxGrid const *)arg1)->GetSelectedRows();
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 {
18085 resultobj = wxArrayInt2PyList_helper(result);
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18094 PyObject *resultobj = 0;
18095 wxGrid *arg1 = (wxGrid *) 0 ;
18096 wxArrayInt result;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 PyObject *swig_obj[1] ;
18100
18101 if (!args) SWIG_fail;
18102 swig_obj[0] = args;
18103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18104 if (!SWIG_IsOK(res1)) {
18105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18106 }
18107 arg1 = reinterpret_cast< wxGrid * >(argp1);
18108 {
18109 PyThreadState* __tstate = wxPyBeginAllowThreads();
18110 result = ((wxGrid const *)arg1)->GetSelectedCols();
18111 wxPyEndAllowThreads(__tstate);
18112 if (PyErr_Occurred()) SWIG_fail;
18113 }
18114 {
18115 resultobj = wxArrayInt2PyList_helper(result);
18116 }
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj = 0;
18125 wxGrid *arg1 = (wxGrid *) 0 ;
18126 int arg2 ;
18127 void *argp1 = 0 ;
18128 int res1 = 0 ;
18129 int val2 ;
18130 int ecode2 = 0 ;
18131 PyObject * obj0 = 0 ;
18132 PyObject * obj1 = 0 ;
18133 char * kwnames[] = {
18134 (char *) "self",(char *) "row", NULL
18135 };
18136
18137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18139 if (!SWIG_IsOK(res1)) {
18140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18141 }
18142 arg1 = reinterpret_cast< wxGrid * >(argp1);
18143 ecode2 = SWIG_AsVal_int(obj1, &val2);
18144 if (!SWIG_IsOK(ecode2)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18146 }
18147 arg2 = static_cast< int >(val2);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->DeselectRow(arg2);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj = 0;
18163 wxGrid *arg1 = (wxGrid *) 0 ;
18164 int arg2 ;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 int val2 ;
18168 int ecode2 = 0 ;
18169 PyObject * obj0 = 0 ;
18170 PyObject * obj1 = 0 ;
18171 char * kwnames[] = {
18172 (char *) "self",(char *) "col", NULL
18173 };
18174
18175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18177 if (!SWIG_IsOK(res1)) {
18178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18179 }
18180 arg1 = reinterpret_cast< wxGrid * >(argp1);
18181 ecode2 = SWIG_AsVal_int(obj1, &val2);
18182 if (!SWIG_IsOK(ecode2)) {
18183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18184 }
18185 arg2 = static_cast< int >(val2);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 (arg1)->DeselectCol(arg2);
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_Py_Void();
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18200 PyObject *resultobj = 0;
18201 wxGrid *arg1 = (wxGrid *) 0 ;
18202 int arg2 ;
18203 int arg3 ;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 int val2 ;
18207 int ecode2 = 0 ;
18208 int val3 ;
18209 int ecode3 = 0 ;
18210 PyObject * obj0 = 0 ;
18211 PyObject * obj1 = 0 ;
18212 PyObject * obj2 = 0 ;
18213 char * kwnames[] = {
18214 (char *) "self",(char *) "row",(char *) "col", NULL
18215 };
18216
18217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18219 if (!SWIG_IsOK(res1)) {
18220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18221 }
18222 arg1 = reinterpret_cast< wxGrid * >(argp1);
18223 ecode2 = SWIG_AsVal_int(obj1, &val2);
18224 if (!SWIG_IsOK(ecode2)) {
18225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18226 }
18227 arg2 = static_cast< int >(val2);
18228 ecode3 = SWIG_AsVal_int(obj2, &val3);
18229 if (!SWIG_IsOK(ecode3)) {
18230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18231 }
18232 arg3 = static_cast< int >(val3);
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 (arg1)->DeselectCell(arg2,arg3);
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 resultobj = SWIG_Py_Void();
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18247 PyObject *resultobj = 0;
18248 wxGrid *arg1 = (wxGrid *) 0 ;
18249 wxGridCellCoords *arg2 = 0 ;
18250 wxGridCellCoords *arg3 = 0 ;
18251 wxRect result;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 wxGridCellCoords temp2 ;
18255 wxGridCellCoords temp3 ;
18256 PyObject * obj0 = 0 ;
18257 PyObject * obj1 = 0 ;
18258 PyObject * obj2 = 0 ;
18259 char * kwnames[] = {
18260 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18261 };
18262
18263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18265 if (!SWIG_IsOK(res1)) {
18266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18267 }
18268 arg1 = reinterpret_cast< wxGrid * >(argp1);
18269 {
18270 arg2 = &temp2;
18271 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18272 }
18273 {
18274 arg3 = &temp3;
18275 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18276 }
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 PyObject *resultobj = 0;
18292 wxGrid *arg1 = (wxGrid *) 0 ;
18293 wxColour result;
18294 void *argp1 = 0 ;
18295 int res1 = 0 ;
18296 PyObject *swig_obj[1] ;
18297
18298 if (!args) SWIG_fail;
18299 swig_obj[0] = args;
18300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18303 }
18304 arg1 = reinterpret_cast< wxGrid * >(argp1);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18319 PyObject *resultobj = 0;
18320 wxGrid *arg1 = (wxGrid *) 0 ;
18321 wxColour result;
18322 void *argp1 = 0 ;
18323 int res1 = 0 ;
18324 PyObject *swig_obj[1] ;
18325
18326 if (!args) SWIG_fail;
18327 swig_obj[0] = args;
18328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18329 if (!SWIG_IsOK(res1)) {
18330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18331 }
18332 arg1 = reinterpret_cast< wxGrid * >(argp1);
18333 {
18334 PyThreadState* __tstate = wxPyBeginAllowThreads();
18335 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj = 0;
18348 wxGrid *arg1 = (wxGrid *) 0 ;
18349 wxColour *arg2 = 0 ;
18350 void *argp1 = 0 ;
18351 int res1 = 0 ;
18352 wxColour temp2 ;
18353 PyObject * obj0 = 0 ;
18354 PyObject * obj1 = 0 ;
18355 char * kwnames[] = {
18356 (char *) "self",(char *) "c", NULL
18357 };
18358
18359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18361 if (!SWIG_IsOK(res1)) {
18362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18363 }
18364 arg1 = reinterpret_cast< wxGrid * >(argp1);
18365 {
18366 arg2 = &temp2;
18367 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18368 }
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18372 wxPyEndAllowThreads(__tstate);
18373 if (PyErr_Occurred()) SWIG_fail;
18374 }
18375 resultobj = SWIG_Py_Void();
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj = 0;
18384 wxGrid *arg1 = (wxGrid *) 0 ;
18385 wxColour *arg2 = 0 ;
18386 void *argp1 = 0 ;
18387 int res1 = 0 ;
18388 wxColour temp2 ;
18389 PyObject * obj0 = 0 ;
18390 PyObject * obj1 = 0 ;
18391 char * kwnames[] = {
18392 (char *) "self",(char *) "c", NULL
18393 };
18394
18395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18399 }
18400 arg1 = reinterpret_cast< wxGrid * >(argp1);
18401 {
18402 arg2 = &temp2;
18403 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18404 }
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 resultobj = SWIG_Py_Void();
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj = 0;
18420 wxGrid *arg1 = (wxGrid *) 0 ;
18421 wxString *arg2 = 0 ;
18422 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18423 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 bool temp2 = false ;
18427 void *argp3 = 0 ;
18428 int res3 = 0 ;
18429 void *argp4 = 0 ;
18430 int res4 = 0 ;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 PyObject * obj2 = 0 ;
18434 PyObject * obj3 = 0 ;
18435 char * kwnames[] = {
18436 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18437 };
18438
18439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18443 }
18444 arg1 = reinterpret_cast< wxGrid * >(argp1);
18445 {
18446 arg2 = wxString_in_helper(obj1);
18447 if (arg2 == NULL) SWIG_fail;
18448 temp2 = true;
18449 }
18450 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18451 if (!SWIG_IsOK(res3)) {
18452 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18453 }
18454 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18455 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18456 if (!SWIG_IsOK(res4)) {
18457 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18458 }
18459 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18460 {
18461 PyThreadState* __tstate = wxPyBeginAllowThreads();
18462 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18463 wxPyEndAllowThreads(__tstate);
18464 if (PyErr_Occurred()) SWIG_fail;
18465 }
18466 resultobj = SWIG_Py_Void();
18467 {
18468 if (temp2)
18469 delete arg2;
18470 }
18471 return resultobj;
18472 fail:
18473 {
18474 if (temp2)
18475 delete arg2;
18476 }
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18482 PyObject *resultobj = 0;
18483 wxGrid *arg1 = (wxGrid *) 0 ;
18484 int arg2 ;
18485 int arg3 ;
18486 wxGridCellEditor *result = 0 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 int val2 ;
18490 int ecode2 = 0 ;
18491 int val3 ;
18492 int ecode3 = 0 ;
18493 PyObject * obj0 = 0 ;
18494 PyObject * obj1 = 0 ;
18495 PyObject * obj2 = 0 ;
18496 char * kwnames[] = {
18497 (char *) "self",(char *) "row",(char *) "col", NULL
18498 };
18499
18500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18504 }
18505 arg1 = reinterpret_cast< wxGrid * >(argp1);
18506 ecode2 = SWIG_AsVal_int(obj1, &val2);
18507 if (!SWIG_IsOK(ecode2)) {
18508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18509 }
18510 arg2 = static_cast< int >(val2);
18511 ecode3 = SWIG_AsVal_int(obj2, &val3);
18512 if (!SWIG_IsOK(ecode3)) {
18513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18514 }
18515 arg3 = static_cast< int >(val3);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 {
18523 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18524 }
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj = 0;
18533 wxGrid *arg1 = (wxGrid *) 0 ;
18534 int arg2 ;
18535 int arg3 ;
18536 wxGridCellRenderer *result = 0 ;
18537 void *argp1 = 0 ;
18538 int res1 = 0 ;
18539 int val2 ;
18540 int ecode2 = 0 ;
18541 int val3 ;
18542 int ecode3 = 0 ;
18543 PyObject * obj0 = 0 ;
18544 PyObject * obj1 = 0 ;
18545 PyObject * obj2 = 0 ;
18546 char * kwnames[] = {
18547 (char *) "self",(char *) "row",(char *) "col", NULL
18548 };
18549
18550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18552 if (!SWIG_IsOK(res1)) {
18553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18554 }
18555 arg1 = reinterpret_cast< wxGrid * >(argp1);
18556 ecode2 = SWIG_AsVal_int(obj1, &val2);
18557 if (!SWIG_IsOK(ecode2)) {
18558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18559 }
18560 arg2 = static_cast< int >(val2);
18561 ecode3 = SWIG_AsVal_int(obj2, &val3);
18562 if (!SWIG_IsOK(ecode3)) {
18563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18564 }
18565 arg3 = static_cast< int >(val3);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 {
18573 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18574 }
18575 return resultobj;
18576 fail:
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18582 PyObject *resultobj = 0;
18583 wxGrid *arg1 = (wxGrid *) 0 ;
18584 wxString *arg2 = 0 ;
18585 wxGridCellEditor *result = 0 ;
18586 void *argp1 = 0 ;
18587 int res1 = 0 ;
18588 bool temp2 = false ;
18589 PyObject * obj0 = 0 ;
18590 PyObject * obj1 = 0 ;
18591 char * kwnames[] = {
18592 (char *) "self",(char *) "typeName", NULL
18593 };
18594
18595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18597 if (!SWIG_IsOK(res1)) {
18598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18599 }
18600 arg1 = reinterpret_cast< wxGrid * >(argp1);
18601 {
18602 arg2 = wxString_in_helper(obj1);
18603 if (arg2 == NULL) SWIG_fail;
18604 temp2 = true;
18605 }
18606 {
18607 PyThreadState* __tstate = wxPyBeginAllowThreads();
18608 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18609 wxPyEndAllowThreads(__tstate);
18610 if (PyErr_Occurred()) SWIG_fail;
18611 }
18612 {
18613 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18614 }
18615 {
18616 if (temp2)
18617 delete arg2;
18618 }
18619 return resultobj;
18620 fail:
18621 {
18622 if (temp2)
18623 delete arg2;
18624 }
18625 return NULL;
18626 }
18627
18628
18629 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj = 0;
18631 wxGrid *arg1 = (wxGrid *) 0 ;
18632 wxString *arg2 = 0 ;
18633 wxGridCellRenderer *result = 0 ;
18634 void *argp1 = 0 ;
18635 int res1 = 0 ;
18636 bool temp2 = false ;
18637 PyObject * obj0 = 0 ;
18638 PyObject * obj1 = 0 ;
18639 char * kwnames[] = {
18640 (char *) "self",(char *) "typeName", NULL
18641 };
18642
18643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18647 }
18648 arg1 = reinterpret_cast< wxGrid * >(argp1);
18649 {
18650 arg2 = wxString_in_helper(obj1);
18651 if (arg2 == NULL) SWIG_fail;
18652 temp2 = true;
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 {
18661 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18662 }
18663 {
18664 if (temp2)
18665 delete arg2;
18666 }
18667 return resultobj;
18668 fail:
18669 {
18670 if (temp2)
18671 delete arg2;
18672 }
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18678 PyObject *resultobj = 0;
18679 wxGrid *arg1 = (wxGrid *) 0 ;
18680 int arg2 ;
18681 int arg3 ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 int val2 ;
18685 int ecode2 = 0 ;
18686 int val3 ;
18687 int ecode3 = 0 ;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 PyObject * obj2 = 0 ;
18691 char * kwnames[] = {
18692 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18693 };
18694
18695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18697 if (!SWIG_IsOK(res1)) {
18698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18699 }
18700 arg1 = reinterpret_cast< wxGrid * >(argp1);
18701 ecode2 = SWIG_AsVal_int(obj1, &val2);
18702 if (!SWIG_IsOK(ecode2)) {
18703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18704 }
18705 arg2 = static_cast< int >(val2);
18706 ecode3 = SWIG_AsVal_int(obj2, &val3);
18707 if (!SWIG_IsOK(ecode3)) {
18708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18709 }
18710 arg3 = static_cast< int >(val3);
18711 {
18712 PyThreadState* __tstate = wxPyBeginAllowThreads();
18713 (arg1)->SetMargins(arg2,arg3);
18714 wxPyEndAllowThreads(__tstate);
18715 if (PyErr_Occurred()) SWIG_fail;
18716 }
18717 resultobj = SWIG_Py_Void();
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18725 PyObject *resultobj = 0;
18726 wxGrid *arg1 = (wxGrid *) 0 ;
18727 wxWindow *result = 0 ;
18728 void *argp1 = 0 ;
18729 int res1 = 0 ;
18730 PyObject *swig_obj[1] ;
18731
18732 if (!args) SWIG_fail;
18733 swig_obj[0] = args;
18734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18735 if (!SWIG_IsOK(res1)) {
18736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18737 }
18738 arg1 = reinterpret_cast< wxGrid * >(argp1);
18739 {
18740 PyThreadState* __tstate = wxPyBeginAllowThreads();
18741 result = (wxWindow *)(arg1)->GetGridWindow();
18742 wxPyEndAllowThreads(__tstate);
18743 if (PyErr_Occurred()) SWIG_fail;
18744 }
18745 {
18746 resultobj = wxPyMake_wxObject(result, 0);
18747 }
18748 return resultobj;
18749 fail:
18750 return NULL;
18751 }
18752
18753
18754 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18755 PyObject *resultobj = 0;
18756 wxGrid *arg1 = (wxGrid *) 0 ;
18757 wxWindow *result = 0 ;
18758 void *argp1 = 0 ;
18759 int res1 = 0 ;
18760 PyObject *swig_obj[1] ;
18761
18762 if (!args) SWIG_fail;
18763 swig_obj[0] = args;
18764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18765 if (!SWIG_IsOK(res1)) {
18766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18767 }
18768 arg1 = reinterpret_cast< wxGrid * >(argp1);
18769 {
18770 PyThreadState* __tstate = wxPyBeginAllowThreads();
18771 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 {
18776 resultobj = wxPyMake_wxObject(result, 0);
18777 }
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18785 PyObject *resultobj = 0;
18786 wxGrid *arg1 = (wxGrid *) 0 ;
18787 wxWindow *result = 0 ;
18788 void *argp1 = 0 ;
18789 int res1 = 0 ;
18790 PyObject *swig_obj[1] ;
18791
18792 if (!args) SWIG_fail;
18793 swig_obj[0] = args;
18794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18795 if (!SWIG_IsOK(res1)) {
18796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18797 }
18798 arg1 = reinterpret_cast< wxGrid * >(argp1);
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18802 wxPyEndAllowThreads(__tstate);
18803 if (PyErr_Occurred()) SWIG_fail;
18804 }
18805 {
18806 resultobj = wxPyMake_wxObject(result, 0);
18807 }
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18815 PyObject *resultobj = 0;
18816 wxGrid *arg1 = (wxGrid *) 0 ;
18817 wxWindow *result = 0 ;
18818 void *argp1 = 0 ;
18819 int res1 = 0 ;
18820 PyObject *swig_obj[1] ;
18821
18822 if (!args) SWIG_fail;
18823 swig_obj[0] = args;
18824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18825 if (!SWIG_IsOK(res1)) {
18826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18827 }
18828 arg1 = reinterpret_cast< wxGrid * >(argp1);
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 {
18836 resultobj = wxPyMake_wxObject(result, 0);
18837 }
18838 return resultobj;
18839 fail:
18840 return NULL;
18841 }
18842
18843
18844 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18845 PyObject *resultobj = 0;
18846 wxGrid *arg1 = (wxGrid *) 0 ;
18847 int arg2 ;
18848 void *argp1 = 0 ;
18849 int res1 = 0 ;
18850 int val2 ;
18851 int ecode2 = 0 ;
18852 PyObject * obj0 = 0 ;
18853 PyObject * obj1 = 0 ;
18854 char * kwnames[] = {
18855 (char *) "self",(char *) "x", NULL
18856 };
18857
18858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18860 if (!SWIG_IsOK(res1)) {
18861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18862 }
18863 arg1 = reinterpret_cast< wxGrid * >(argp1);
18864 ecode2 = SWIG_AsVal_int(obj1, &val2);
18865 if (!SWIG_IsOK(ecode2)) {
18866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18867 }
18868 arg2 = static_cast< int >(val2);
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 (arg1)->SetScrollLineX(arg2);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_Py_Void();
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18883 PyObject *resultobj = 0;
18884 wxGrid *arg1 = (wxGrid *) 0 ;
18885 int arg2 ;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 int val2 ;
18889 int ecode2 = 0 ;
18890 PyObject * obj0 = 0 ;
18891 PyObject * obj1 = 0 ;
18892 char * kwnames[] = {
18893 (char *) "self",(char *) "y", NULL
18894 };
18895
18896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18898 if (!SWIG_IsOK(res1)) {
18899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18900 }
18901 arg1 = reinterpret_cast< wxGrid * >(argp1);
18902 ecode2 = SWIG_AsVal_int(obj1, &val2);
18903 if (!SWIG_IsOK(ecode2)) {
18904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18905 }
18906 arg2 = static_cast< int >(val2);
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 (arg1)->SetScrollLineY(arg2);
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_Py_Void();
18914 return resultobj;
18915 fail:
18916 return NULL;
18917 }
18918
18919
18920 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18921 PyObject *resultobj = 0;
18922 wxGrid *arg1 = (wxGrid *) 0 ;
18923 int result;
18924 void *argp1 = 0 ;
18925 int res1 = 0 ;
18926 PyObject *swig_obj[1] ;
18927
18928 if (!args) SWIG_fail;
18929 swig_obj[0] = args;
18930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18931 if (!SWIG_IsOK(res1)) {
18932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18933 }
18934 arg1 = reinterpret_cast< wxGrid * >(argp1);
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 resultobj = SWIG_From_int(static_cast< int >(result));
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18949 PyObject *resultobj = 0;
18950 wxGrid *arg1 = (wxGrid *) 0 ;
18951 int result;
18952 void *argp1 = 0 ;
18953 int res1 = 0 ;
18954 PyObject *swig_obj[1] ;
18955
18956 if (!args) SWIG_fail;
18957 swig_obj[0] = args;
18958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18959 if (!SWIG_IsOK(res1)) {
18960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18961 }
18962 arg1 = reinterpret_cast< wxGrid * >(argp1);
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18966 wxPyEndAllowThreads(__tstate);
18967 if (PyErr_Occurred()) SWIG_fail;
18968 }
18969 resultobj = SWIG_From_int(static_cast< int >(result));
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18977 PyObject *resultobj = 0;
18978 wxGrid *arg1 = (wxGrid *) 0 ;
18979 int arg2 ;
18980 int result;
18981 void *argp1 = 0 ;
18982 int res1 = 0 ;
18983 int val2 ;
18984 int ecode2 = 0 ;
18985 PyObject * obj0 = 0 ;
18986 PyObject * obj1 = 0 ;
18987 char * kwnames[] = {
18988 (char *) "self",(char *) "x", NULL
18989 };
18990
18991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18993 if (!SWIG_IsOK(res1)) {
18994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18995 }
18996 arg1 = reinterpret_cast< wxGrid * >(argp1);
18997 ecode2 = SWIG_AsVal_int(obj1, &val2);
18998 if (!SWIG_IsOK(ecode2)) {
18999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
19000 }
19001 arg2 = static_cast< int >(val2);
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19005 wxPyEndAllowThreads(__tstate);
19006 if (PyErr_Occurred()) SWIG_fail;
19007 }
19008 resultobj = SWIG_From_int(static_cast< int >(result));
19009 return resultobj;
19010 fail:
19011 return NULL;
19012 }
19013
19014
19015 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19016 PyObject *resultobj = 0;
19017 wxGrid *arg1 = (wxGrid *) 0 ;
19018 int arg2 ;
19019 int result;
19020 void *argp1 = 0 ;
19021 int res1 = 0 ;
19022 int val2 ;
19023 int ecode2 = 0 ;
19024 PyObject * obj0 = 0 ;
19025 PyObject * obj1 = 0 ;
19026 char * kwnames[] = {
19027 (char *) "self",(char *) "y", NULL
19028 };
19029
19030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19032 if (!SWIG_IsOK(res1)) {
19033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19034 }
19035 arg1 = reinterpret_cast< wxGrid * >(argp1);
19036 ecode2 = SWIG_AsVal_int(obj1, &val2);
19037 if (!SWIG_IsOK(ecode2)) {
19038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19039 }
19040 arg2 = static_cast< int >(val2);
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19044 wxPyEndAllowThreads(__tstate);
19045 if (PyErr_Occurred()) SWIG_fail;
19046 }
19047 resultobj = SWIG_From_int(static_cast< int >(result));
19048 return resultobj;
19049 fail:
19050 return NULL;
19051 }
19052
19053
19054 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19055 PyObject *resultobj = 0;
19056 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19057 SwigValueWrapper<wxVisualAttributes > result;
19058 int val1 ;
19059 int ecode1 = 0 ;
19060 PyObject * obj0 = 0 ;
19061 char * kwnames[] = {
19062 (char *) "variant", NULL
19063 };
19064
19065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19066 if (obj0) {
19067 ecode1 = SWIG_AsVal_int(obj0, &val1);
19068 if (!SWIG_IsOK(ecode1)) {
19069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19070 }
19071 arg1 = static_cast< wxWindowVariant >(val1);
19072 }
19073 {
19074 if (!wxPyCheckForApp()) SWIG_fail;
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 result = wxGrid::GetClassDefaultAttributes(arg1);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19088 PyObject *obj;
19089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19090 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19091 return SWIG_Py_Void();
19092 }
19093
19094 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19095 return SWIG_Python_InitShadowInstance(args);
19096 }
19097
19098 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 int arg1 ;
19101 wxEventType arg2 ;
19102 wxGrid *arg3 = (wxGrid *) 0 ;
19103 int arg4 = (int) -1 ;
19104 int arg5 = (int) -1 ;
19105 int arg6 = (int) -1 ;
19106 int arg7 = (int) -1 ;
19107 bool arg8 = (bool) true ;
19108 bool arg9 = (bool) false ;
19109 bool arg10 = (bool) false ;
19110 bool arg11 = (bool) false ;
19111 bool arg12 = (bool) false ;
19112 wxGridEvent *result = 0 ;
19113 int val1 ;
19114 int ecode1 = 0 ;
19115 int val2 ;
19116 int ecode2 = 0 ;
19117 void *argp3 = 0 ;
19118 int res3 = 0 ;
19119 int val4 ;
19120 int ecode4 = 0 ;
19121 int val5 ;
19122 int ecode5 = 0 ;
19123 int val6 ;
19124 int ecode6 = 0 ;
19125 int val7 ;
19126 int ecode7 = 0 ;
19127 bool val8 ;
19128 int ecode8 = 0 ;
19129 bool val9 ;
19130 int ecode9 = 0 ;
19131 bool val10 ;
19132 int ecode10 = 0 ;
19133 bool val11 ;
19134 int ecode11 = 0 ;
19135 bool val12 ;
19136 int ecode12 = 0 ;
19137 PyObject * obj0 = 0 ;
19138 PyObject * obj1 = 0 ;
19139 PyObject * obj2 = 0 ;
19140 PyObject * obj3 = 0 ;
19141 PyObject * obj4 = 0 ;
19142 PyObject * obj5 = 0 ;
19143 PyObject * obj6 = 0 ;
19144 PyObject * obj7 = 0 ;
19145 PyObject * obj8 = 0 ;
19146 PyObject * obj9 = 0 ;
19147 PyObject * obj10 = 0 ;
19148 PyObject * obj11 = 0 ;
19149 char * kwnames[] = {
19150 (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
19151 };
19152
19153 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;
19154 ecode1 = SWIG_AsVal_int(obj0, &val1);
19155 if (!SWIG_IsOK(ecode1)) {
19156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19157 }
19158 arg1 = static_cast< int >(val1);
19159 ecode2 = SWIG_AsVal_int(obj1, &val2);
19160 if (!SWIG_IsOK(ecode2)) {
19161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19162 }
19163 arg2 = static_cast< wxEventType >(val2);
19164 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19165 if (!SWIG_IsOK(res3)) {
19166 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19167 }
19168 arg3 = reinterpret_cast< wxGrid * >(argp3);
19169 if (obj3) {
19170 ecode4 = SWIG_AsVal_int(obj3, &val4);
19171 if (!SWIG_IsOK(ecode4)) {
19172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19173 }
19174 arg4 = static_cast< int >(val4);
19175 }
19176 if (obj4) {
19177 ecode5 = SWIG_AsVal_int(obj4, &val5);
19178 if (!SWIG_IsOK(ecode5)) {
19179 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19180 }
19181 arg5 = static_cast< int >(val5);
19182 }
19183 if (obj5) {
19184 ecode6 = SWIG_AsVal_int(obj5, &val6);
19185 if (!SWIG_IsOK(ecode6)) {
19186 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19187 }
19188 arg6 = static_cast< int >(val6);
19189 }
19190 if (obj6) {
19191 ecode7 = SWIG_AsVal_int(obj6, &val7);
19192 if (!SWIG_IsOK(ecode7)) {
19193 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19194 }
19195 arg7 = static_cast< int >(val7);
19196 }
19197 if (obj7) {
19198 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19199 if (!SWIG_IsOK(ecode8)) {
19200 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19201 }
19202 arg8 = static_cast< bool >(val8);
19203 }
19204 if (obj8) {
19205 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19206 if (!SWIG_IsOK(ecode9)) {
19207 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19208 }
19209 arg9 = static_cast< bool >(val9);
19210 }
19211 if (obj9) {
19212 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19213 if (!SWIG_IsOK(ecode10)) {
19214 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19215 }
19216 arg10 = static_cast< bool >(val10);
19217 }
19218 if (obj10) {
19219 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19220 if (!SWIG_IsOK(ecode11)) {
19221 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19222 }
19223 arg11 = static_cast< bool >(val11);
19224 }
19225 if (obj11) {
19226 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19227 if (!SWIG_IsOK(ecode12)) {
19228 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19229 }
19230 arg12 = static_cast< bool >(val12);
19231 }
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19246 PyObject *resultobj = 0;
19247 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19248 int result;
19249 void *argp1 = 0 ;
19250 int res1 = 0 ;
19251 PyObject *swig_obj[1] ;
19252
19253 if (!args) SWIG_fail;
19254 swig_obj[0] = args;
19255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19256 if (!SWIG_IsOK(res1)) {
19257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19258 }
19259 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 result = (int)(arg1)->GetRow();
19263 wxPyEndAllowThreads(__tstate);
19264 if (PyErr_Occurred()) SWIG_fail;
19265 }
19266 resultobj = SWIG_From_int(static_cast< int >(result));
19267 return resultobj;
19268 fail:
19269 return NULL;
19270 }
19271
19272
19273 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19274 PyObject *resultobj = 0;
19275 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19276 int result;
19277 void *argp1 = 0 ;
19278 int res1 = 0 ;
19279 PyObject *swig_obj[1] ;
19280
19281 if (!args) SWIG_fail;
19282 swig_obj[0] = args;
19283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19284 if (!SWIG_IsOK(res1)) {
19285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19286 }
19287 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = (int)(arg1)->GetCol();
19291 wxPyEndAllowThreads(__tstate);
19292 if (PyErr_Occurred()) SWIG_fail;
19293 }
19294 resultobj = SWIG_From_int(static_cast< int >(result));
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19302 PyObject *resultobj = 0;
19303 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19304 wxPoint result;
19305 void *argp1 = 0 ;
19306 int res1 = 0 ;
19307 PyObject *swig_obj[1] ;
19308
19309 if (!args) SWIG_fail;
19310 swig_obj[0] = args;
19311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19312 if (!SWIG_IsOK(res1)) {
19313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19314 }
19315 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19316 {
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = (arg1)->GetPosition();
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19323 return resultobj;
19324 fail:
19325 return NULL;
19326 }
19327
19328
19329 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19330 PyObject *resultobj = 0;
19331 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19332 bool result;
19333 void *argp1 = 0 ;
19334 int res1 = 0 ;
19335 PyObject *swig_obj[1] ;
19336
19337 if (!args) SWIG_fail;
19338 swig_obj[0] = args;
19339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19340 if (!SWIG_IsOK(res1)) {
19341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19342 }
19343 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = (bool)(arg1)->Selecting();
19347 wxPyEndAllowThreads(__tstate);
19348 if (PyErr_Occurred()) SWIG_fail;
19349 }
19350 {
19351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19352 }
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19360 PyObject *resultobj = 0;
19361 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19362 bool result;
19363 void *argp1 = 0 ;
19364 int res1 = 0 ;
19365 PyObject *swig_obj[1] ;
19366
19367 if (!args) SWIG_fail;
19368 swig_obj[0] = args;
19369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19370 if (!SWIG_IsOK(res1)) {
19371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19372 }
19373 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19374 {
19375 PyThreadState* __tstate = wxPyBeginAllowThreads();
19376 result = (bool)(arg1)->ControlDown();
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19382 }
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19390 PyObject *resultobj = 0;
19391 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19392 bool result;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject *swig_obj[1] ;
19396
19397 if (!args) SWIG_fail;
19398 swig_obj[0] = args;
19399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19400 if (!SWIG_IsOK(res1)) {
19401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19402 }
19403 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 result = (bool)(arg1)->MetaDown();
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 {
19411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19412 }
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19420 PyObject *resultobj = 0;
19421 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19422 bool result;
19423 void *argp1 = 0 ;
19424 int res1 = 0 ;
19425 PyObject *swig_obj[1] ;
19426
19427 if (!args) SWIG_fail;
19428 swig_obj[0] = args;
19429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19432 }
19433 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 result = (bool)(arg1)->ShiftDown();
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 {
19441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19442 }
19443 return resultobj;
19444 fail:
19445 return NULL;
19446 }
19447
19448
19449 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19450 PyObject *resultobj = 0;
19451 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19452 bool result;
19453 void *argp1 = 0 ;
19454 int res1 = 0 ;
19455 PyObject *swig_obj[1] ;
19456
19457 if (!args) SWIG_fail;
19458 swig_obj[0] = args;
19459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19460 if (!SWIG_IsOK(res1)) {
19461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19462 }
19463 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (bool)(arg1)->AltDown();
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19472 }
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19480 PyObject *resultobj = 0;
19481 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19482 bool result;
19483 void *argp1 = 0 ;
19484 int res1 = 0 ;
19485 PyObject *swig_obj[1] ;
19486
19487 if (!args) SWIG_fail;
19488 swig_obj[0] = args;
19489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19490 if (!SWIG_IsOK(res1)) {
19491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19492 }
19493 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = (bool)(arg1)->CmdDown();
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 {
19501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19502 }
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19510 PyObject *obj;
19511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19512 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19513 return SWIG_Py_Void();
19514 }
19515
19516 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19517 return SWIG_Python_InitShadowInstance(args);
19518 }
19519
19520 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj = 0;
19522 int arg1 ;
19523 wxEventType arg2 ;
19524 wxGrid *arg3 = (wxGrid *) 0 ;
19525 int arg4 = (int) -1 ;
19526 int arg5 = (int) -1 ;
19527 int arg6 = (int) -1 ;
19528 bool arg7 = (bool) false ;
19529 bool arg8 = (bool) false ;
19530 bool arg9 = (bool) false ;
19531 bool arg10 = (bool) false ;
19532 wxGridSizeEvent *result = 0 ;
19533 int val1 ;
19534 int ecode1 = 0 ;
19535 int val2 ;
19536 int ecode2 = 0 ;
19537 void *argp3 = 0 ;
19538 int res3 = 0 ;
19539 int val4 ;
19540 int ecode4 = 0 ;
19541 int val5 ;
19542 int ecode5 = 0 ;
19543 int val6 ;
19544 int ecode6 = 0 ;
19545 bool val7 ;
19546 int ecode7 = 0 ;
19547 bool val8 ;
19548 int ecode8 = 0 ;
19549 bool val9 ;
19550 int ecode9 = 0 ;
19551 bool val10 ;
19552 int ecode10 = 0 ;
19553 PyObject * obj0 = 0 ;
19554 PyObject * obj1 = 0 ;
19555 PyObject * obj2 = 0 ;
19556 PyObject * obj3 = 0 ;
19557 PyObject * obj4 = 0 ;
19558 PyObject * obj5 = 0 ;
19559 PyObject * obj6 = 0 ;
19560 PyObject * obj7 = 0 ;
19561 PyObject * obj8 = 0 ;
19562 PyObject * obj9 = 0 ;
19563 char * kwnames[] = {
19564 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19565 };
19566
19567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19568 ecode1 = SWIG_AsVal_int(obj0, &val1);
19569 if (!SWIG_IsOK(ecode1)) {
19570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19571 }
19572 arg1 = static_cast< int >(val1);
19573 ecode2 = SWIG_AsVal_int(obj1, &val2);
19574 if (!SWIG_IsOK(ecode2)) {
19575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19576 }
19577 arg2 = static_cast< wxEventType >(val2);
19578 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19579 if (!SWIG_IsOK(res3)) {
19580 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19581 }
19582 arg3 = reinterpret_cast< wxGrid * >(argp3);
19583 if (obj3) {
19584 ecode4 = SWIG_AsVal_int(obj3, &val4);
19585 if (!SWIG_IsOK(ecode4)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19587 }
19588 arg4 = static_cast< int >(val4);
19589 }
19590 if (obj4) {
19591 ecode5 = SWIG_AsVal_int(obj4, &val5);
19592 if (!SWIG_IsOK(ecode5)) {
19593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19594 }
19595 arg5 = static_cast< int >(val5);
19596 }
19597 if (obj5) {
19598 ecode6 = SWIG_AsVal_int(obj5, &val6);
19599 if (!SWIG_IsOK(ecode6)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19601 }
19602 arg6 = static_cast< int >(val6);
19603 }
19604 if (obj6) {
19605 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19606 if (!SWIG_IsOK(ecode7)) {
19607 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19608 }
19609 arg7 = static_cast< bool >(val7);
19610 }
19611 if (obj7) {
19612 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19613 if (!SWIG_IsOK(ecode8)) {
19614 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19615 }
19616 arg8 = static_cast< bool >(val8);
19617 }
19618 if (obj8) {
19619 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19620 if (!SWIG_IsOK(ecode9)) {
19621 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19622 }
19623 arg9 = static_cast< bool >(val9);
19624 }
19625 if (obj9) {
19626 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19627 if (!SWIG_IsOK(ecode10)) {
19628 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19629 }
19630 arg10 = static_cast< bool >(val10);
19631 }
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19635 wxPyEndAllowThreads(__tstate);
19636 if (PyErr_Occurred()) SWIG_fail;
19637 }
19638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 PyObject *resultobj = 0;
19647 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19648 int result;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 PyObject *swig_obj[1] ;
19652
19653 if (!args) SWIG_fail;
19654 swig_obj[0] = args;
19655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19658 }
19659 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (int)(arg1)->GetRowOrCol();
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 resultobj = SWIG_From_int(static_cast< int >(result));
19667 return resultobj;
19668 fail:
19669 return NULL;
19670 }
19671
19672
19673 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19674 PyObject *resultobj = 0;
19675 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19676 wxPoint result;
19677 void *argp1 = 0 ;
19678 int res1 = 0 ;
19679 PyObject *swig_obj[1] ;
19680
19681 if (!args) SWIG_fail;
19682 swig_obj[0] = args;
19683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19684 if (!SWIG_IsOK(res1)) {
19685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19686 }
19687 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = (arg1)->GetPosition();
19691 wxPyEndAllowThreads(__tstate);
19692 if (PyErr_Occurred()) SWIG_fail;
19693 }
19694 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19695 return resultobj;
19696 fail:
19697 return NULL;
19698 }
19699
19700
19701 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19702 PyObject *resultobj = 0;
19703 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19704 bool result;
19705 void *argp1 = 0 ;
19706 int res1 = 0 ;
19707 PyObject *swig_obj[1] ;
19708
19709 if (!args) SWIG_fail;
19710 swig_obj[0] = args;
19711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19712 if (!SWIG_IsOK(res1)) {
19713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19714 }
19715 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (bool)(arg1)->ControlDown();
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 {
19723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19724 }
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19732 PyObject *resultobj = 0;
19733 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19734 bool result;
19735 void *argp1 = 0 ;
19736 int res1 = 0 ;
19737 PyObject *swig_obj[1] ;
19738
19739 if (!args) SWIG_fail;
19740 swig_obj[0] = args;
19741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19742 if (!SWIG_IsOK(res1)) {
19743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19744 }
19745 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19746 {
19747 PyThreadState* __tstate = wxPyBeginAllowThreads();
19748 result = (bool)(arg1)->MetaDown();
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19762 PyObject *resultobj = 0;
19763 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19764 bool result;
19765 void *argp1 = 0 ;
19766 int res1 = 0 ;
19767 PyObject *swig_obj[1] ;
19768
19769 if (!args) SWIG_fail;
19770 swig_obj[0] = args;
19771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19772 if (!SWIG_IsOK(res1)) {
19773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19774 }
19775 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 result = (bool)(arg1)->ShiftDown();
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 {
19783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19784 }
19785 return resultobj;
19786 fail:
19787 return NULL;
19788 }
19789
19790
19791 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19792 PyObject *resultobj = 0;
19793 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19794 bool result;
19795 void *argp1 = 0 ;
19796 int res1 = 0 ;
19797 PyObject *swig_obj[1] ;
19798
19799 if (!args) SWIG_fail;
19800 swig_obj[0] = args;
19801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19802 if (!SWIG_IsOK(res1)) {
19803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19804 }
19805 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19806 {
19807 PyThreadState* __tstate = wxPyBeginAllowThreads();
19808 result = (bool)(arg1)->AltDown();
19809 wxPyEndAllowThreads(__tstate);
19810 if (PyErr_Occurred()) SWIG_fail;
19811 }
19812 {
19813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19814 }
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822 PyObject *resultobj = 0;
19823 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19824 bool result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 PyObject *swig_obj[1] ;
19828
19829 if (!args) SWIG_fail;
19830 swig_obj[0] = args;
19831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19832 if (!SWIG_IsOK(res1)) {
19833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19834 }
19835 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19836 {
19837 PyThreadState* __tstate = wxPyBeginAllowThreads();
19838 result = (bool)(arg1)->CmdDown();
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19852 PyObject *obj;
19853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19854 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19855 return SWIG_Py_Void();
19856 }
19857
19858 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19859 return SWIG_Python_InitShadowInstance(args);
19860 }
19861
19862 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19863 PyObject *resultobj = 0;
19864 int arg1 ;
19865 wxEventType arg2 ;
19866 wxGrid *arg3 = (wxGrid *) 0 ;
19867 wxGridCellCoords *arg4 = 0 ;
19868 wxGridCellCoords *arg5 = 0 ;
19869 bool arg6 = (bool) true ;
19870 bool arg7 = (bool) false ;
19871 bool arg8 = (bool) false ;
19872 bool arg9 = (bool) false ;
19873 bool arg10 = (bool) false ;
19874 wxGridRangeSelectEvent *result = 0 ;
19875 int val1 ;
19876 int ecode1 = 0 ;
19877 int val2 ;
19878 int ecode2 = 0 ;
19879 void *argp3 = 0 ;
19880 int res3 = 0 ;
19881 wxGridCellCoords temp4 ;
19882 wxGridCellCoords temp5 ;
19883 bool val6 ;
19884 int ecode6 = 0 ;
19885 bool val7 ;
19886 int ecode7 = 0 ;
19887 bool val8 ;
19888 int ecode8 = 0 ;
19889 bool val9 ;
19890 int ecode9 = 0 ;
19891 bool val10 ;
19892 int ecode10 = 0 ;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 PyObject * obj2 = 0 ;
19896 PyObject * obj3 = 0 ;
19897 PyObject * obj4 = 0 ;
19898 PyObject * obj5 = 0 ;
19899 PyObject * obj6 = 0 ;
19900 PyObject * obj7 = 0 ;
19901 PyObject * obj8 = 0 ;
19902 PyObject * obj9 = 0 ;
19903 char * kwnames[] = {
19904 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19905 };
19906
19907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19908 ecode1 = SWIG_AsVal_int(obj0, &val1);
19909 if (!SWIG_IsOK(ecode1)) {
19910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19911 }
19912 arg1 = static_cast< int >(val1);
19913 ecode2 = SWIG_AsVal_int(obj1, &val2);
19914 if (!SWIG_IsOK(ecode2)) {
19915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19916 }
19917 arg2 = static_cast< wxEventType >(val2);
19918 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19919 if (!SWIG_IsOK(res3)) {
19920 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19921 }
19922 arg3 = reinterpret_cast< wxGrid * >(argp3);
19923 {
19924 arg4 = &temp4;
19925 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19926 }
19927 {
19928 arg5 = &temp5;
19929 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19930 }
19931 if (obj5) {
19932 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19933 if (!SWIG_IsOK(ecode6)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19935 }
19936 arg6 = static_cast< bool >(val6);
19937 }
19938 if (obj6) {
19939 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19940 if (!SWIG_IsOK(ecode7)) {
19941 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19942 }
19943 arg7 = static_cast< bool >(val7);
19944 }
19945 if (obj7) {
19946 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19947 if (!SWIG_IsOK(ecode8)) {
19948 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19949 }
19950 arg8 = static_cast< bool >(val8);
19951 }
19952 if (obj8) {
19953 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19954 if (!SWIG_IsOK(ecode9)) {
19955 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19956 }
19957 arg9 = static_cast< bool >(val9);
19958 }
19959 if (obj9) {
19960 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19961 if (!SWIG_IsOK(ecode10)) {
19962 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19963 }
19964 arg10 = static_cast< bool >(val10);
19965 }
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19980 PyObject *resultobj = 0;
19981 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19982 wxGridCellCoords result;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 PyObject *swig_obj[1] ;
19986
19987 if (!args) SWIG_fail;
19988 swig_obj[0] = args;
19989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19990 if (!SWIG_IsOK(res1)) {
19991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19992 }
19993 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19994 {
19995 PyThreadState* __tstate = wxPyBeginAllowThreads();
19996 result = (arg1)->GetTopLeftCoords();
19997 wxPyEndAllowThreads(__tstate);
19998 if (PyErr_Occurred()) SWIG_fail;
19999 }
20000 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20008 PyObject *resultobj = 0;
20009 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20010 wxGridCellCoords result;
20011 void *argp1 = 0 ;
20012 int res1 = 0 ;
20013 PyObject *swig_obj[1] ;
20014
20015 if (!args) SWIG_fail;
20016 swig_obj[0] = args;
20017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20018 if (!SWIG_IsOK(res1)) {
20019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20020 }
20021 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20022 {
20023 PyThreadState* __tstate = wxPyBeginAllowThreads();
20024 result = (arg1)->GetBottomRightCoords();
20025 wxPyEndAllowThreads(__tstate);
20026 if (PyErr_Occurred()) SWIG_fail;
20027 }
20028 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20036 PyObject *resultobj = 0;
20037 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20038 int result;
20039 void *argp1 = 0 ;
20040 int res1 = 0 ;
20041 PyObject *swig_obj[1] ;
20042
20043 if (!args) SWIG_fail;
20044 swig_obj[0] = args;
20045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20048 }
20049 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (int)(arg1)->GetTopRow();
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 resultobj = SWIG_From_int(static_cast< int >(result));
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064 PyObject *resultobj = 0;
20065 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20066 int result;
20067 void *argp1 = 0 ;
20068 int res1 = 0 ;
20069 PyObject *swig_obj[1] ;
20070
20071 if (!args) SWIG_fail;
20072 swig_obj[0] = args;
20073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20076 }
20077 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = (int)(arg1)->GetBottomRow();
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 resultobj = SWIG_From_int(static_cast< int >(result));
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20092 PyObject *resultobj = 0;
20093 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20094 int result;
20095 void *argp1 = 0 ;
20096 int res1 = 0 ;
20097 PyObject *swig_obj[1] ;
20098
20099 if (!args) SWIG_fail;
20100 swig_obj[0] = args;
20101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20102 if (!SWIG_IsOK(res1)) {
20103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20104 }
20105 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20106 {
20107 PyThreadState* __tstate = wxPyBeginAllowThreads();
20108 result = (int)(arg1)->GetLeftCol();
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 resultobj = SWIG_From_int(static_cast< int >(result));
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 PyObject *resultobj = 0;
20121 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20122 int result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 PyObject *swig_obj[1] ;
20126
20127 if (!args) SWIG_fail;
20128 swig_obj[0] = args;
20129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20132 }
20133 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (int)(arg1)->GetRightCol();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_From_int(static_cast< int >(result));
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *resultobj = 0;
20149 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20150 bool result;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 PyObject *swig_obj[1] ;
20154
20155 if (!args) SWIG_fail;
20156 swig_obj[0] = args;
20157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20158 if (!SWIG_IsOK(res1)) {
20159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20160 }
20161 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (bool)(arg1)->Selecting();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 {
20169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20170 }
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20178 PyObject *resultobj = 0;
20179 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20180 bool result;
20181 void *argp1 = 0 ;
20182 int res1 = 0 ;
20183 PyObject *swig_obj[1] ;
20184
20185 if (!args) SWIG_fail;
20186 swig_obj[0] = args;
20187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20188 if (!SWIG_IsOK(res1)) {
20189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20190 }
20191 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (bool)(arg1)->ControlDown();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 {
20199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20200 }
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20208 PyObject *resultobj = 0;
20209 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20210 bool result;
20211 void *argp1 = 0 ;
20212 int res1 = 0 ;
20213 PyObject *swig_obj[1] ;
20214
20215 if (!args) SWIG_fail;
20216 swig_obj[0] = args;
20217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20218 if (!SWIG_IsOK(res1)) {
20219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20220 }
20221 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)(arg1)->MetaDown();
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20238 PyObject *resultobj = 0;
20239 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20240 bool result;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 PyObject *swig_obj[1] ;
20244
20245 if (!args) SWIG_fail;
20246 swig_obj[0] = args;
20247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20248 if (!SWIG_IsOK(res1)) {
20249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20250 }
20251 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20252 {
20253 PyThreadState* __tstate = wxPyBeginAllowThreads();
20254 result = (bool)(arg1)->ShiftDown();
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 {
20259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20260 }
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 PyObject *resultobj = 0;
20269 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20270 bool result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 PyObject *swig_obj[1] ;
20274
20275 if (!args) SWIG_fail;
20276 swig_obj[0] = args;
20277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20280 }
20281 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (bool)(arg1)->AltDown();
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 {
20289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 PyObject *resultobj = 0;
20299 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20300 bool result;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 PyObject *swig_obj[1] ;
20304
20305 if (!args) SWIG_fail;
20306 swig_obj[0] = args;
20307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20308 if (!SWIG_IsOK(res1)) {
20309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20310 }
20311 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (bool)(arg1)->CmdDown();
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 {
20319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *obj;
20329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20330 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20331 return SWIG_Py_Void();
20332 }
20333
20334 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 return SWIG_Python_InitShadowInstance(args);
20336 }
20337
20338 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20339 PyObject *resultobj = 0;
20340 int arg1 ;
20341 wxEventType arg2 ;
20342 wxObject *arg3 = (wxObject *) 0 ;
20343 int arg4 ;
20344 int arg5 ;
20345 wxControl *arg6 = (wxControl *) 0 ;
20346 wxGridEditorCreatedEvent *result = 0 ;
20347 int val1 ;
20348 int ecode1 = 0 ;
20349 int val2 ;
20350 int ecode2 = 0 ;
20351 void *argp3 = 0 ;
20352 int res3 = 0 ;
20353 int val4 ;
20354 int ecode4 = 0 ;
20355 int val5 ;
20356 int ecode5 = 0 ;
20357 void *argp6 = 0 ;
20358 int res6 = 0 ;
20359 PyObject * obj0 = 0 ;
20360 PyObject * obj1 = 0 ;
20361 PyObject * obj2 = 0 ;
20362 PyObject * obj3 = 0 ;
20363 PyObject * obj4 = 0 ;
20364 PyObject * obj5 = 0 ;
20365 char * kwnames[] = {
20366 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20367 };
20368
20369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20370 ecode1 = SWIG_AsVal_int(obj0, &val1);
20371 if (!SWIG_IsOK(ecode1)) {
20372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20373 }
20374 arg1 = static_cast< int >(val1);
20375 ecode2 = SWIG_AsVal_int(obj1, &val2);
20376 if (!SWIG_IsOK(ecode2)) {
20377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20378 }
20379 arg2 = static_cast< wxEventType >(val2);
20380 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20381 if (!SWIG_IsOK(res3)) {
20382 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20383 }
20384 arg3 = reinterpret_cast< wxObject * >(argp3);
20385 ecode4 = SWIG_AsVal_int(obj3, &val4);
20386 if (!SWIG_IsOK(ecode4)) {
20387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20388 }
20389 arg4 = static_cast< int >(val4);
20390 ecode5 = SWIG_AsVal_int(obj4, &val5);
20391 if (!SWIG_IsOK(ecode5)) {
20392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20393 }
20394 arg5 = static_cast< int >(val5);
20395 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20396 if (!SWIG_IsOK(res6)) {
20397 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20398 }
20399 arg6 = reinterpret_cast< wxControl * >(argp6);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20414 PyObject *resultobj = 0;
20415 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20416 int result;
20417 void *argp1 = 0 ;
20418 int res1 = 0 ;
20419 PyObject *swig_obj[1] ;
20420
20421 if (!args) SWIG_fail;
20422 swig_obj[0] = args;
20423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20426 }
20427 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = (int)(arg1)->GetRow();
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 resultobj = SWIG_From_int(static_cast< int >(result));
20435 return resultobj;
20436 fail:
20437 return NULL;
20438 }
20439
20440
20441 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 PyObject *resultobj = 0;
20443 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20444 int result;
20445 void *argp1 = 0 ;
20446 int res1 = 0 ;
20447 PyObject *swig_obj[1] ;
20448
20449 if (!args) SWIG_fail;
20450 swig_obj[0] = args;
20451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20452 if (!SWIG_IsOK(res1)) {
20453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20454 }
20455 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (int)(arg1)->GetCol();
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 resultobj = SWIG_From_int(static_cast< int >(result));
20463 return resultobj;
20464 fail:
20465 return NULL;
20466 }
20467
20468
20469 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20470 PyObject *resultobj = 0;
20471 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20472 wxControl *result = 0 ;
20473 void *argp1 = 0 ;
20474 int res1 = 0 ;
20475 PyObject *swig_obj[1] ;
20476
20477 if (!args) SWIG_fail;
20478 swig_obj[0] = args;
20479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20480 if (!SWIG_IsOK(res1)) {
20481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20482 }
20483 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (wxControl *)(arg1)->GetControl();
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 {
20491 resultobj = wxPyMake_wxObject(result, 0);
20492 }
20493 return resultobj;
20494 fail:
20495 return NULL;
20496 }
20497
20498
20499 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20500 PyObject *resultobj = 0;
20501 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20502 int arg2 ;
20503 void *argp1 = 0 ;
20504 int res1 = 0 ;
20505 int val2 ;
20506 int ecode2 = 0 ;
20507 PyObject * obj0 = 0 ;
20508 PyObject * obj1 = 0 ;
20509 char * kwnames[] = {
20510 (char *) "self",(char *) "row", NULL
20511 };
20512
20513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20515 if (!SWIG_IsOK(res1)) {
20516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20517 }
20518 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20519 ecode2 = SWIG_AsVal_int(obj1, &val2);
20520 if (!SWIG_IsOK(ecode2)) {
20521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20522 }
20523 arg2 = static_cast< int >(val2);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 (arg1)->SetRow(arg2);
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_Py_Void();
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20538 PyObject *resultobj = 0;
20539 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20540 int arg2 ;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 int val2 ;
20544 int ecode2 = 0 ;
20545 PyObject * obj0 = 0 ;
20546 PyObject * obj1 = 0 ;
20547 char * kwnames[] = {
20548 (char *) "self",(char *) "col", NULL
20549 };
20550
20551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20553 if (!SWIG_IsOK(res1)) {
20554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20555 }
20556 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20557 ecode2 = SWIG_AsVal_int(obj1, &val2);
20558 if (!SWIG_IsOK(ecode2)) {
20559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20560 }
20561 arg2 = static_cast< int >(val2);
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 (arg1)->SetCol(arg2);
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 resultobj = SWIG_Py_Void();
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj = 0;
20577 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20578 wxControl *arg2 = (wxControl *) 0 ;
20579 void *argp1 = 0 ;
20580 int res1 = 0 ;
20581 void *argp2 = 0 ;
20582 int res2 = 0 ;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 char * kwnames[] = {
20586 (char *) "self",(char *) "ctrl", NULL
20587 };
20588
20589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20591 if (!SWIG_IsOK(res1)) {
20592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20593 }
20594 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20596 if (!SWIG_IsOK(res2)) {
20597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20598 }
20599 arg2 = reinterpret_cast< wxControl * >(argp2);
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 (arg1)->SetControl(arg2);
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 resultobj = SWIG_Py_Void();
20607 return resultobj;
20608 fail:
20609 return NULL;
20610 }
20611
20612
20613 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20614 PyObject *obj;
20615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20616 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20617 return SWIG_Py_Void();
20618 }
20619
20620 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20621 return SWIG_Python_InitShadowInstance(args);
20622 }
20623
20624 static PyMethodDef SwigMethods[] = {
20625 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20627 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20629 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20630 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20631 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20634 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20635 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20636 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20639 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20640 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20641 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20642 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20643 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20644 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20645 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20646 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20648 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20650 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20652 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20653 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20654 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20655 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20656 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20658 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20659 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20661 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20662 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20663 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20664 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20665 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20666 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20667 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20669 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20674 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20675 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20681 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20683 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20684 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20685 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20688 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20689 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20690 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20691 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20692 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20693 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20695 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20696 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20698 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20699 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20700 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20703 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20704 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20706 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20707 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20709 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20710 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20711 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20712 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20713 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20716 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20717 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20719 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20720 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20731 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20732 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20733 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20734 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20735 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20736 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20737 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20738 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20739 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20740 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20741 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20742 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20743 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20744 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20747 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20748 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20750 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20751 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20752 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20760 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20761 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20762 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20768 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20769 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20770 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20773 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20775 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20776 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20777 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20790 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20801 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20806 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20807 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20809 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20810 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20811 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20813 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20814 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20816 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20818 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20820 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20822 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20824 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20825 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20826 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20828 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20829 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20831 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20836 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20837 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20838 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20840 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20844 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20845 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20846 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20848 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20850 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20860 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20861 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20862 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20863 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20864 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20867 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20868 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20869 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20870 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20871 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20872 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20873 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20874 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20881 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20882 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20890 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20891 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20896 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20897 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20898 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20899 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20900 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20901 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20902 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20903 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20904 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20905 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20908 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20909 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20912 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20913 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20914 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20930 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20931 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20933 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20934 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20936 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20937 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20939 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20940 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20942 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20943 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20953 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20954 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20956 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20958 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20960 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20962 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20964 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20966 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20980 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20987 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20988 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21002 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21006 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21015 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21016 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21017 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21019 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21020 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21021 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21022 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21023 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21028 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21029 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21038 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21039 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21040 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21041 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21044 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21045 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21049 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21050 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21052 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21053 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21054 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21055 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21056 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21057 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21058 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21059 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21060 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21061 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21062 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21064 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21065 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21066 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21067 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21068 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21069 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21070 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21071 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21072 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21074 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21075 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21076 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21077 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21078 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21079 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21080 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21081 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21082 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21083 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21084 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21085 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21086 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21087 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21089 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21090 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21091 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21095 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21096 { NULL, NULL, 0, NULL }
21097 };
21098
21099
21100 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21101
21102 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21103 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21104 }
21105 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21106 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21107 }
21108 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21109 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21110 }
21111 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21112 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21113 }
21114 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21115 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21116 }
21117 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21118 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21119 }
21120 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21121 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21122 }
21123 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21124 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21125 }
21126 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21127 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21128 }
21129 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21130 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21131 }
21132 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21133 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21134 }
21135 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21136 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21137 }
21138 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21139 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21140 }
21141 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21142 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21143 }
21144 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21145 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21146 }
21147 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21148 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21149 }
21150 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21151 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21152 }
21153 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21154 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21155 }
21156 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21157 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21158 }
21159 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21160 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21161 }
21162 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21163 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21164 }
21165 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21166 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21167 }
21168 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21169 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21170 }
21171 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21172 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21173 }
21174 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21175 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21176 }
21177 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21178 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21179 }
21180 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21181 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21182 }
21183 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21184 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21185 }
21186 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21187 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21188 }
21189 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21190 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21191 }
21192 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21193 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21194 }
21195 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21196 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21197 }
21198 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21199 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21200 }
21201 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21202 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21203 }
21204 static void *_p_wxGridTo_p_wxPanel(void *x) {
21205 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21206 }
21207 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21208 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21209 }
21210 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21211 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21212 }
21213 static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
21214 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21215 }
21216 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21217 return (void *)((wxPanel *) ((wxPyPanel *) x));
21218 }
21219 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21220 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21221 }
21222 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21223 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21224 }
21225 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21226 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21227 }
21228 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21229 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21230 }
21231 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21232 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21233 }
21234 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21235 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21236 }
21237 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21238 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21239 }
21240 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21241 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21242 }
21243 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21244 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21245 }
21246 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21247 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21248 }
21249 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21250 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21251 }
21252 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21253 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21254 }
21255 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21256 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21257 }
21258 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21259 return (void *)((wxWindow *) ((wxMenuBar *) x));
21260 }
21261 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21262 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21263 }
21264 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21265 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21266 }
21267 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21268 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21269 }
21270 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21271 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21272 }
21273 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21274 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21275 }
21276 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21277 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21278 }
21279 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21280 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21281 }
21282 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21283 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21284 }
21285 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21286 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21287 }
21288 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21289 return (void *)((wxWindow *) ((wxPanel *) x));
21290 }
21291 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21292 return (void *)((wxWindow *) ((wxStatusBar *) x));
21293 }
21294 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21295 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21296 }
21297 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21298 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21299 }
21300 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21301 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21302 }
21303 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21304 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21305 }
21306 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21307 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21308 }
21309 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21310 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21311 }
21312 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21313 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21314 }
21315 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21316 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21317 }
21318 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21319 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21320 }
21321 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21322 return (void *)((wxWindow *) ((wxSashWindow *) x));
21323 }
21324 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21325 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21326 }
21327 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21328 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21329 }
21330 static void *_p_wxControlTo_p_wxWindow(void *x) {
21331 return (void *)((wxWindow *) ((wxControl *) x));
21332 }
21333 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21334 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21335 }
21336 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21337 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21338 }
21339 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21340 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21341 }
21342 static void *_p_wxGridTo_p_wxWindow(void *x) {
21343 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21344 }
21345 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21346 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21347 }
21348 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21349 return (void *)((wxWindow *) ((wxPyWindow *) x));
21350 }
21351 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21352 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21353 }
21354 static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
21355 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21356 }
21357 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21358 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21359 }
21360 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21361 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21362 }
21363 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21364 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21365 }
21366 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21367 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21368 }
21369 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21370 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21371 }
21372 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21373 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21374 }
21375 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21376 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21377 }
21378 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21379 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21380 }
21381 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21382 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21383 }
21384 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21385 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21386 }
21387 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21388 return (void *)((wxControl *) ((wxControlWithItems *) x));
21389 }
21390 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21391 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21392 }
21393 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21394 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21395 }
21396 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21397 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21398 }
21399 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21400 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21401 }
21402 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21403 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21404 }
21405 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21406 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21407 }
21408 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21409 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21410 }
21411 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21412 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21413 }
21414 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21415 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21416 }
21417 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21418 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21419 }
21420 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21421 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21422 }
21423 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21424 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21425 }
21426 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21427 return (void *)((wxEvent *) ((wxPyEvent *) x));
21428 }
21429 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21430 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21431 }
21432 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21433 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21434 }
21435 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21436 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21437 }
21438 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21439 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21440 }
21441 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21442 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21443 }
21444 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21445 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21446 }
21447 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21448 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21449 }
21450 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21451 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21452 }
21453 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21454 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21455 }
21456 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21457 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21458 }
21459 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21460 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21461 }
21462 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21463 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21464 }
21465 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21466 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21467 }
21468 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21469 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21470 }
21471 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21472 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21473 }
21474 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21475 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21476 }
21477 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21478 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21479 }
21480 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21481 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21482 }
21483 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21484 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21485 }
21486 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21487 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21488 }
21489 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21490 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21491 }
21492 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21493 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21494 }
21495 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21496 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21497 }
21498 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21499 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21500 }
21501 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21502 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21503 }
21504 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21505 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21506 }
21507 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21508 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21509 }
21510 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21511 return (void *)((wxEvent *) ((wxShowEvent *) x));
21512 }
21513 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21514 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21515 }
21516 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21517 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21518 }
21519 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21520 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21521 }
21522 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21523 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21524 }
21525 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21526 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21527 }
21528 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21529 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21530 }
21531 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21532 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21533 }
21534 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21536 }
21537 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21539 }
21540 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21542 }
21543 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21545 }
21546 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) ((wxSizerItem *) x));
21548 }
21549 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21551 }
21552 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21554 }
21555 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21557 }
21558 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21560 }
21561 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21563 }
21564 static void *_p_wxSizerTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) ((wxSizer *) x));
21566 }
21567 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21569 }
21570 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21572 }
21573 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21575 }
21576 static void *_p_wxEventTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) ((wxEvent *) x));
21578 }
21579 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) ((wxFontData *) x));
21581 }
21582 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) ((wxPrintData *) x));
21584 }
21585 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21587 }
21588 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21590 }
21591 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21593 }
21594 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21596 }
21597 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21599 }
21600 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21602 }
21603 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21605 }
21606 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21608 }
21609 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21611 }
21612 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21614 }
21615 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21617 }
21618 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21620 }
21621 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21623 }
21624 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21626 }
21627 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21629 }
21630 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21632 }
21633 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21635 }
21636 static void *_p_wxControlTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21638 }
21639 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21641 }
21642 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21644 }
21645 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) ((wxFSFile *) x));
21647 }
21648 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21650 }
21651 static void *_p_wxGridTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21653 }
21654 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21656 }
21657 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21659 }
21660 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21661 return (void *)((wxObject *) ((wxColourData *) x));
21662 }
21663 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21664 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21665 }
21666 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21667 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21668 }
21669 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21670 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21671 }
21672 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21673 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21674 }
21675 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21677 }
21678 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21679 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21680 }
21681 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21682 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21683 }
21684 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21685 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21686 }
21687 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21688 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21689 }
21690 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21691 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21692 }
21693 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21694 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21695 }
21696 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21697 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21698 }
21699 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21700 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21701 }
21702 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21703 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21704 }
21705 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21706 return (void *)((wxObject *) ((wxPrinter *) x));
21707 }
21708 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21709 return (void *)((wxObject *) ((wxMenuItem *) x));
21710 }
21711 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21712 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21713 }
21714 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21715 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21716 }
21717 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21718 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21719 }
21720 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21721 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21722 }
21723 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21724 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21725 }
21726 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21727 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21728 }
21729 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21730 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21731 }
21732 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21733 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21734 }
21735 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21736 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21737 }
21738 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21739 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21740 }
21741 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21742 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21743 }
21744 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21745 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21746 }
21747 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21748 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21749 }
21750 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21751 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21752 }
21753 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21754 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21755 }
21756 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21757 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21758 }
21759 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21760 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21761 }
21762 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21763 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21764 }
21765 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21766 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21767 }
21768 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21769 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21770 }
21771 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21772 return (void *)((wxObject *) ((wxImageHandler *) x));
21773 }
21774 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21775 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21776 }
21777 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21778 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21779 }
21780 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21781 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21782 }
21783 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21784 return (void *)((wxObject *) ((wxEvtHandler *) x));
21785 }
21786 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21787 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21788 }
21789 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21790 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21791 }
21792 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21793 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21794 }
21795 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21796 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21797 }
21798 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21799 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21800 }
21801 static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
21802 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21803 }
21804 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21805 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21806 }
21807 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21808 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21809 }
21810 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21811 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21812 }
21813 static void *_p_wxImageTo_p_wxObject(void *x) {
21814 return (void *)((wxObject *) ((wxImage *) x));
21815 }
21816 static void *_p_wxFrameTo_p_wxObject(void *x) {
21817 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21818 }
21819 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21820 return (void *)((wxObject *) ((wxPyPrintout *) x));
21821 }
21822 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21823 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21824 }
21825 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21826 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21827 }
21828 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21829 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21830 }
21831 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21832 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21833 }
21834 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21835 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21836 }
21837 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21838 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21839 }
21840 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21841 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21842 }
21843 static void *_p_wxWindowTo_p_wxObject(void *x) {
21844 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21845 }
21846 static void *_p_wxMenuTo_p_wxObject(void *x) {
21847 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21848 }
21849 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21850 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21851 }
21852 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21853 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21854 }
21855 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21856 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21857 }
21858 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21859 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21860 }
21861 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21862 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21863 }
21864 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21865 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21866 }
21867 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21868 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21869 }
21870 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21871 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21872 }
21873 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21874 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21875 }
21876 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21877 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21878 }
21879 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21880 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21881 }
21882 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21883 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21884 }
21885 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21886 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21887 }
21888 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21889 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21890 }
21891 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21892 return (void *)((wxObject *) ((wxPrintPreview *) x));
21893 }
21894 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21895 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21896 }
21897 static void *_p_wxPanelTo_p_wxObject(void *x) {
21898 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21899 }
21900 static void *_p_wxDialogTo_p_wxObject(void *x) {
21901 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21902 }
21903 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21904 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21905 }
21906 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21907 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21908 }
21909 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21910 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21911 }
21912 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21913 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21914 }
21915 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21916 return (void *)((wxObject *) ((wxPrintDialog *) x));
21917 }
21918 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21919 return (void *)((wxObject *) ((wxFileSystem *) x));
21920 }
21921 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21922 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21923 }
21924 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21925 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21926 }
21927 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21928 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21929 }
21930 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21931 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21932 }
21933 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21934 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21935 }
21936 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21937 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21938 }
21939 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21940 return (void *)((wxObject *) ((wxGridTableBase *) x));
21941 }
21942 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21943 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21944 }
21945 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21946 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21947 }
21948 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21949 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21950 }
21951 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21952 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21953 }
21954 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21955 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21956 }
21957 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21958 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21959 }
21960 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21961 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21962 }
21963 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21964 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21965 }
21966 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21967 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21968 }
21969 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21970 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21971 }
21972 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21973 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21974 }
21975 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21976 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21977 }
21978 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21979 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21980 }
21981 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21982 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21983 }
21984 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21985 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21986 }
21987 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21988 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21989 }
21990 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21991 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21992 }
21993 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21994 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21995 }
21996 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21997 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21998 }
21999 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
22000 return (void *)((wxEvtHandler *) ((wxMenu *) x));
22001 }
22002 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
22003 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
22004 }
22005 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
22006 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
22007 }
22008 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22009 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22010 }
22011 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22012 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22013 }
22014 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
22015 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
22016 }
22017 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22018 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22019 }
22020 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22021 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22022 }
22023 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22024 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22025 }
22026 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22027 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22028 }
22029 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22030 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22031 }
22032 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22033 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22034 }
22035 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22036 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22037 }
22038 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22039 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22040 }
22041 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22042 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22043 }
22044 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22045 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22046 }
22047 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22048 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22049 }
22050 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22051 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22052 }
22053 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22054 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22055 }
22056 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22057 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22058 }
22059 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22060 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22061 }
22062 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22063 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22064 }
22065 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22066 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22067 }
22068 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22069 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22070 }
22071 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22072 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22073 }
22074 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22075 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22076 }
22077 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22078 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22079 }
22080 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22081 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22082 }
22083 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22084 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22085 }
22086 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22087 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22088 }
22089 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22090 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22091 }
22092 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22093 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22094 }
22095 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22096 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22097 }
22098 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22099 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22100 }
22101 static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
22102 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
22103 }
22104 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22105 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22106 }
22107 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22108 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22109 }
22110 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22111 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22112 }
22113 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22114 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22115 }
22116 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22117 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22118 }
22119 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22120 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22121 }
22122 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22123 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22124 }
22125 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22126 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22127 }
22128 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22129 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22130 }
22131 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22132 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22133 }
22134 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22135 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22136 }
22137 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22138 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22139 }
22140 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22141 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22142 }
22143 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22144 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22145 }
22146 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22147 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22148 }
22149 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22150 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22151 }
22152 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22153 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22154 }
22155 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22156 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22157 }
22158 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22159 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22160 }
22161 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22162 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22163 }
22164 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22165 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22166 }
22167 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22168 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22169 }
22170 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22171 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22172 }
22173 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22174 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22175 }
22176 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22177 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22178 }
22179 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22180 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22181 }
22182 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22183 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22184 }
22185 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22186 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22187 }
22188 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22189 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22190 }
22191 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22192 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22193 }
22194 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22195 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22196 }
22197 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22198 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22199 }
22200 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22201 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22202 }
22203 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22204 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22205 }
22206 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22207 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22208 }
22209 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22210 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22211 }
22212 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22213 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22214 }
22215 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22216 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22217 }
22218 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22219 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22220 }
22221 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22222 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22223 }
22224 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22225 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22226 }
22227 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22228 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22229 }
22230 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22231 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22232 }
22233 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22234 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};
22235 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22236 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22237 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22238 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22239 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22240 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22241 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22242 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22243 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22244 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22245 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22246 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22247 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22248 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22249 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22250 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22255 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22256 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22257 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22258 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22259 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22260 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22263 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22265 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22266 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22267 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22272 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22273 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22274 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22275 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22276 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22277 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22278 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22279 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22280 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22281 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22282 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22283 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22284 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22285 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22286 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22287 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22288 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22289 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22290 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22291 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22292 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22293 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22294 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22295 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22296 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22297 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22298 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22299 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22300 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22301 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22302 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22303 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22304 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22305 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22306 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22307 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22308 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22309 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22310 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22311 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22312 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22313 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22314 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22315 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22316 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22317 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22318 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22319 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22320 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22321 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22322 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22323 static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
22324 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22325 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22326 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22327 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22328 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22329 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22330 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22331 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22332 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22333 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22334 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22335 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22336 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22337 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22338 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22339 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22340 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22341 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22342 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22343 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22344 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22345 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22346 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22347 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22348 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22349 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22350 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22351 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22352 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22353 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22354 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22355 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22356 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22357 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22358 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22359 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22360 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22361 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22362 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22363 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22364 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22365 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22366 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22367 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22368 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22369 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22370 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22371 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22372 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22373 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22374 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22375 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22376 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22378 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22380 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22381 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22382 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22398 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22399 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22400 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22401 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22402 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22403 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22404 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22405 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22406 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22407 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22408 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22409 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22410 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22411 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22412 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22413 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22414 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22415 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22416 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22417 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22418 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22419 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22420 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22421 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22422 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22423 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22424 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22425 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22426
22427 static swig_type_info *swig_type_initial[] = {
22428 &_swigt__p_char,
22429 &_swigt__p_form_ops_t,
22430 &_swigt__p_int,
22431 &_swigt__p_long,
22432 &_swigt__p_unsigned_char,
22433 &_swigt__p_unsigned_int,
22434 &_swigt__p_unsigned_long,
22435 &_swigt__p_wxANIHandler,
22436 &_swigt__p_wxAcceleratorTable,
22437 &_swigt__p_wxActivateEvent,
22438 &_swigt__p_wxArrayString,
22439 &_swigt__p_wxBMPHandler,
22440 &_swigt__p_wxBoxSizer,
22441 &_swigt__p_wxCURHandler,
22442 &_swigt__p_wxCalculateLayoutEvent,
22443 &_swigt__p_wxChildFocusEvent,
22444 &_swigt__p_wxClipboardTextEvent,
22445 &_swigt__p_wxCloseEvent,
22446 &_swigt__p_wxColour,
22447 &_swigt__p_wxColourData,
22448 &_swigt__p_wxColourDialog,
22449 &_swigt__p_wxCommandEvent,
22450 &_swigt__p_wxContextMenuEvent,
22451 &_swigt__p_wxControl,
22452 &_swigt__p_wxControlWithItems,
22453 &_swigt__p_wxDC,
22454 &_swigt__p_wxDateEvent,
22455 &_swigt__p_wxDialog,
22456 &_swigt__p_wxDirDialog,
22457 &_swigt__p_wxDisplayChangedEvent,
22458 &_swigt__p_wxDropFilesEvent,
22459 &_swigt__p_wxDuplexMode,
22460 &_swigt__p_wxEraseEvent,
22461 &_swigt__p_wxEvent,
22462 &_swigt__p_wxEvtHandler,
22463 &_swigt__p_wxFSFile,
22464 &_swigt__p_wxFileDialog,
22465 &_swigt__p_wxFileSystem,
22466 &_swigt__p_wxFindDialogEvent,
22467 &_swigt__p_wxFindReplaceData,
22468 &_swigt__p_wxFindReplaceDialog,
22469 &_swigt__p_wxFlexGridSizer,
22470 &_swigt__p_wxFocusEvent,
22471 &_swigt__p_wxFont,
22472 &_swigt__p_wxFontData,
22473 &_swigt__p_wxFontDialog,
22474 &_swigt__p_wxFrame,
22475 &_swigt__p_wxGBSizerItem,
22476 &_swigt__p_wxGIFHandler,
22477 &_swigt__p_wxGrid,
22478 &_swigt__p_wxGridBagSizer,
22479 &_swigt__p_wxGridCellAttr,
22480 &_swigt__p_wxGridCellAttrProvider,
22481 &_swigt__p_wxGridCellAutoWrapStringEditor,
22482 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22483 &_swigt__p_wxGridCellBoolEditor,
22484 &_swigt__p_wxGridCellBoolRenderer,
22485 &_swigt__p_wxGridCellChoiceEditor,
22486 &_swigt__p_wxGridCellCoords,
22487 &_swigt__p_wxGridCellDateTimeRenderer,
22488 &_swigt__p_wxGridCellEditor,
22489 &_swigt__p_wxGridCellEnumEditor,
22490 &_swigt__p_wxGridCellEnumRenderer,
22491 &_swigt__p_wxGridCellFloatEditor,
22492 &_swigt__p_wxGridCellFloatRenderer,
22493 &_swigt__p_wxGridCellNumberEditor,
22494 &_swigt__p_wxGridCellNumberRenderer,
22495 &_swigt__p_wxGridCellRenderer,
22496 &_swigt__p_wxGridCellStringRenderer,
22497 &_swigt__p_wxGridCellTextEditor,
22498 &_swigt__p_wxGridCellWorker,
22499 &_swigt__p_wxGridEditorCreatedEvent,
22500 &_swigt__p_wxGridEvent,
22501 &_swigt__p_wxGridRangeSelectEvent,
22502 &_swigt__p_wxGridSizeEvent,
22503 &_swigt__p_wxGridSizer,
22504 &_swigt__p_wxGridStringTable,
22505 &_swigt__p_wxGridTableBase,
22506 &_swigt__p_wxGridTableMessage,
22507 &_swigt__p_wxICOHandler,
22508 &_swigt__p_wxIconizeEvent,
22509 &_swigt__p_wxIdleEvent,
22510 &_swigt__p_wxImage,
22511 &_swigt__p_wxImageHandler,
22512 &_swigt__p_wxIndividualLayoutConstraint,
22513 &_swigt__p_wxInitDialogEvent,
22514 &_swigt__p_wxJPEGHandler,
22515 &_swigt__p_wxKeyEvent,
22516 &_swigt__p_wxLayoutAlgorithm,
22517 &_swigt__p_wxLayoutConstraints,
22518 &_swigt__p_wxMDIChildFrame,
22519 &_swigt__p_wxMDIClientWindow,
22520 &_swigt__p_wxMDIParentFrame,
22521 &_swigt__p_wxMaximizeEvent,
22522 &_swigt__p_wxMenu,
22523 &_swigt__p_wxMenuBar,
22524 &_swigt__p_wxMenuEvent,
22525 &_swigt__p_wxMenuItem,
22526 &_swigt__p_wxMessageDialog,
22527 &_swigt__p_wxMiniFrame,
22528 &_swigt__p_wxMouseCaptureChangedEvent,
22529 &_swigt__p_wxMouseCaptureLostEvent,
22530 &_swigt__p_wxMouseEvent,
22531 &_swigt__p_wxMoveEvent,
22532 &_swigt__p_wxMultiChoiceDialog,
22533 &_swigt__p_wxNavigationKeyEvent,
22534 &_swigt__p_wxNcPaintEvent,
22535 &_swigt__p_wxNotifyEvent,
22536 &_swigt__p_wxNumberEntryDialog,
22537 &_swigt__p_wxObject,
22538 &_swigt__p_wxPCXHandler,
22539 &_swigt__p_wxPNGHandler,
22540 &_swigt__p_wxPNMHandler,
22541 &_swigt__p_wxPageSetupDialog,
22542 &_swigt__p_wxPageSetupDialogData,
22543 &_swigt__p_wxPaintEvent,
22544 &_swigt__p_wxPaletteChangedEvent,
22545 &_swigt__p_wxPanel,
22546 &_swigt__p_wxPaperSize,
22547 &_swigt__p_wxPasswordEntryDialog,
22548 &_swigt__p_wxPen,
22549 &_swigt__p_wxPoint,
22550 &_swigt__p_wxPopupWindow,
22551 &_swigt__p_wxPreviewCanvas,
22552 &_swigt__p_wxPreviewControlBar,
22553 &_swigt__p_wxPreviewFrame,
22554 &_swigt__p_wxPrintData,
22555 &_swigt__p_wxPrintDialog,
22556 &_swigt__p_wxPrintDialogData,
22557 &_swigt__p_wxPrintPreview,
22558 &_swigt__p_wxPrinter,
22559 &_swigt__p_wxProgressDialog,
22560 &_swigt__p_wxPyApp,
22561 &_swigt__p_wxPyCommandEvent,
22562 &_swigt__p_wxPyEvent,
22563 &_swigt__p_wxPyGridCellAttrProvider,
22564 &_swigt__p_wxPyGridCellEditor,
22565 &_swigt__p_wxPyGridCellRenderer,
22566 &_swigt__p_wxPyGridTableBase,
22567 &_swigt__p_wxPyHtmlListBox,
22568 &_swigt__p_wxPyImageHandler,
22569 &_swigt__p_wxPyPanel,
22570 &_swigt__p_wxPyPopupTransientWindow,
22571 &_swigt__p_wxPyPreviewControlBar,
22572 &_swigt__p_wxPyPreviewFrame,
22573 &_swigt__p_wxPyPrintPreview,
22574 &_swigt__p_wxPyPrintout,
22575 &_swigt__p_wxPyScrolledWindow,
22576 &_swigt__p_wxPySizer,
22577 &_swigt__p_wxPyTaskBarIcon,
22578 &_swigt__p_wxPyVListBox,
22579 &_swigt__p_wxPyVScrolledWindow,
22580 &_swigt__p_wxPyValidator,
22581 &_swigt__p_wxPyWindow,
22582 &_swigt__p_wxQueryLayoutInfoEvent,
22583 &_swigt__p_wxQueryNewPaletteEvent,
22584 &_swigt__p_wxRect,
22585 &_swigt__p_wxSashEvent,
22586 &_swigt__p_wxSashLayoutWindow,
22587 &_swigt__p_wxSashWindow,
22588 &_swigt__p_wxScrollEvent,
22589 &_swigt__p_wxScrollWinEvent,
22590 &_swigt__p_wxScrolledWindow,
22591 &_swigt__p_wxSetCursorEvent,
22592 &_swigt__p_wxShowEvent,
22593 &_swigt__p_wxSimpleHtmlListBox,
22594 &_swigt__p_wxSingleChoiceDialog,
22595 &_swigt__p_wxSize,
22596 &_swigt__p_wxSizeEvent,
22597 &_swigt__p_wxSizer,
22598 &_swigt__p_wxSizerItem,
22599 &_swigt__p_wxSplashScreen,
22600 &_swigt__p_wxSplashScreenWindow,
22601 &_swigt__p_wxSplitterEvent,
22602 &_swigt__p_wxSplitterWindow,
22603 &_swigt__p_wxStaticBoxSizer,
22604 &_swigt__p_wxStatusBar,
22605 &_swigt__p_wxStdDialogButtonSizer,
22606 &_swigt__p_wxString,
22607 &_swigt__p_wxSysColourChangedEvent,
22608 &_swigt__p_wxTGAHandler,
22609 &_swigt__p_wxTIFFHandler,
22610 &_swigt__p_wxTaskBarIconEvent,
22611 &_swigt__p_wxTextEntryDialog,
22612 &_swigt__p_wxTipWindow,
22613 &_swigt__p_wxTopLevelWindow,
22614 &_swigt__p_wxUpdateUIEvent,
22615 &_swigt__p_wxValidator,
22616 &_swigt__p_wxVisualAttributes,
22617 &_swigt__p_wxWindow,
22618 &_swigt__p_wxWindowCreateEvent,
22619 &_swigt__p_wxWindowDestroyEvent,
22620 &_swigt__p_wxXPMHandler,
22621 };
22622
22623 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22624 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22625 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22626 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22627 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22628 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22629 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22630 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22631 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22632 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22643 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22644 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}};
22645 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22646 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}};
22647 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22653 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22654 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22655 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22656 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22658 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22659 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22662 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22663 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22667 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22668 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22672 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22673 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22674 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22675 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22676 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22677 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22678 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}};
22679 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22680 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22681 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22682 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22683 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22684 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22685 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22686 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22687 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22688 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22689 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22690 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22691 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22692 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22693 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22694 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22695 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22696 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22697 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22698 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22699 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22700 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22701 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22702 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22703 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22704 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22705 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22706 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22707 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22708 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22709 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22710 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22711 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22712 static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22713 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22714 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22715 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22716 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22717 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22718 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22719 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22720 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22721 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22722 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22723 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22724 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22725 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22726 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22727 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22728 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22729 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}};
22730 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22731 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22732 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22733 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22734 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}};
22735 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22736 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22737 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}};
22738 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22739 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22740 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22741 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22742 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22743 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22744 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}};
22745 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}};
22746 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}};
22747 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}};
22748 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22749 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22752 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22753 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}};
22754 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22755 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22756 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}};
22757 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22758 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22763 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22764 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22766 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22767 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22770 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22771 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22772 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22773 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22778 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22779 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22794 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22795 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22798 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22799 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22800 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22801 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22802 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22803 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22804 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22805 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22806 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22807 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22808 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22809 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22810 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22811 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}};
22812 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22813 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22814 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22815 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22816
22817 static swig_cast_info *swig_cast_initial[] = {
22818 _swigc__p_char,
22819 _swigc__p_form_ops_t,
22820 _swigc__p_int,
22821 _swigc__p_long,
22822 _swigc__p_unsigned_char,
22823 _swigc__p_unsigned_int,
22824 _swigc__p_unsigned_long,
22825 _swigc__p_wxANIHandler,
22826 _swigc__p_wxAcceleratorTable,
22827 _swigc__p_wxActivateEvent,
22828 _swigc__p_wxArrayString,
22829 _swigc__p_wxBMPHandler,
22830 _swigc__p_wxBoxSizer,
22831 _swigc__p_wxCURHandler,
22832 _swigc__p_wxCalculateLayoutEvent,
22833 _swigc__p_wxChildFocusEvent,
22834 _swigc__p_wxClipboardTextEvent,
22835 _swigc__p_wxCloseEvent,
22836 _swigc__p_wxColour,
22837 _swigc__p_wxColourData,
22838 _swigc__p_wxColourDialog,
22839 _swigc__p_wxCommandEvent,
22840 _swigc__p_wxContextMenuEvent,
22841 _swigc__p_wxControl,
22842 _swigc__p_wxControlWithItems,
22843 _swigc__p_wxDC,
22844 _swigc__p_wxDateEvent,
22845 _swigc__p_wxDialog,
22846 _swigc__p_wxDirDialog,
22847 _swigc__p_wxDisplayChangedEvent,
22848 _swigc__p_wxDropFilesEvent,
22849 _swigc__p_wxDuplexMode,
22850 _swigc__p_wxEraseEvent,
22851 _swigc__p_wxEvent,
22852 _swigc__p_wxEvtHandler,
22853 _swigc__p_wxFSFile,
22854 _swigc__p_wxFileDialog,
22855 _swigc__p_wxFileSystem,
22856 _swigc__p_wxFindDialogEvent,
22857 _swigc__p_wxFindReplaceData,
22858 _swigc__p_wxFindReplaceDialog,
22859 _swigc__p_wxFlexGridSizer,
22860 _swigc__p_wxFocusEvent,
22861 _swigc__p_wxFont,
22862 _swigc__p_wxFontData,
22863 _swigc__p_wxFontDialog,
22864 _swigc__p_wxFrame,
22865 _swigc__p_wxGBSizerItem,
22866 _swigc__p_wxGIFHandler,
22867 _swigc__p_wxGrid,
22868 _swigc__p_wxGridBagSizer,
22869 _swigc__p_wxGridCellAttr,
22870 _swigc__p_wxGridCellAttrProvider,
22871 _swigc__p_wxGridCellAutoWrapStringEditor,
22872 _swigc__p_wxGridCellAutoWrapStringRenderer,
22873 _swigc__p_wxGridCellBoolEditor,
22874 _swigc__p_wxGridCellBoolRenderer,
22875 _swigc__p_wxGridCellChoiceEditor,
22876 _swigc__p_wxGridCellCoords,
22877 _swigc__p_wxGridCellDateTimeRenderer,
22878 _swigc__p_wxGridCellEditor,
22879 _swigc__p_wxGridCellEnumEditor,
22880 _swigc__p_wxGridCellEnumRenderer,
22881 _swigc__p_wxGridCellFloatEditor,
22882 _swigc__p_wxGridCellFloatRenderer,
22883 _swigc__p_wxGridCellNumberEditor,
22884 _swigc__p_wxGridCellNumberRenderer,
22885 _swigc__p_wxGridCellRenderer,
22886 _swigc__p_wxGridCellStringRenderer,
22887 _swigc__p_wxGridCellTextEditor,
22888 _swigc__p_wxGridCellWorker,
22889 _swigc__p_wxGridEditorCreatedEvent,
22890 _swigc__p_wxGridEvent,
22891 _swigc__p_wxGridRangeSelectEvent,
22892 _swigc__p_wxGridSizeEvent,
22893 _swigc__p_wxGridSizer,
22894 _swigc__p_wxGridStringTable,
22895 _swigc__p_wxGridTableBase,
22896 _swigc__p_wxGridTableMessage,
22897 _swigc__p_wxICOHandler,
22898 _swigc__p_wxIconizeEvent,
22899 _swigc__p_wxIdleEvent,
22900 _swigc__p_wxImage,
22901 _swigc__p_wxImageHandler,
22902 _swigc__p_wxIndividualLayoutConstraint,
22903 _swigc__p_wxInitDialogEvent,
22904 _swigc__p_wxJPEGHandler,
22905 _swigc__p_wxKeyEvent,
22906 _swigc__p_wxLayoutAlgorithm,
22907 _swigc__p_wxLayoutConstraints,
22908 _swigc__p_wxMDIChildFrame,
22909 _swigc__p_wxMDIClientWindow,
22910 _swigc__p_wxMDIParentFrame,
22911 _swigc__p_wxMaximizeEvent,
22912 _swigc__p_wxMenu,
22913 _swigc__p_wxMenuBar,
22914 _swigc__p_wxMenuEvent,
22915 _swigc__p_wxMenuItem,
22916 _swigc__p_wxMessageDialog,
22917 _swigc__p_wxMiniFrame,
22918 _swigc__p_wxMouseCaptureChangedEvent,
22919 _swigc__p_wxMouseCaptureLostEvent,
22920 _swigc__p_wxMouseEvent,
22921 _swigc__p_wxMoveEvent,
22922 _swigc__p_wxMultiChoiceDialog,
22923 _swigc__p_wxNavigationKeyEvent,
22924 _swigc__p_wxNcPaintEvent,
22925 _swigc__p_wxNotifyEvent,
22926 _swigc__p_wxNumberEntryDialog,
22927 _swigc__p_wxObject,
22928 _swigc__p_wxPCXHandler,
22929 _swigc__p_wxPNGHandler,
22930 _swigc__p_wxPNMHandler,
22931 _swigc__p_wxPageSetupDialog,
22932 _swigc__p_wxPageSetupDialogData,
22933 _swigc__p_wxPaintEvent,
22934 _swigc__p_wxPaletteChangedEvent,
22935 _swigc__p_wxPanel,
22936 _swigc__p_wxPaperSize,
22937 _swigc__p_wxPasswordEntryDialog,
22938 _swigc__p_wxPen,
22939 _swigc__p_wxPoint,
22940 _swigc__p_wxPopupWindow,
22941 _swigc__p_wxPreviewCanvas,
22942 _swigc__p_wxPreviewControlBar,
22943 _swigc__p_wxPreviewFrame,
22944 _swigc__p_wxPrintData,
22945 _swigc__p_wxPrintDialog,
22946 _swigc__p_wxPrintDialogData,
22947 _swigc__p_wxPrintPreview,
22948 _swigc__p_wxPrinter,
22949 _swigc__p_wxProgressDialog,
22950 _swigc__p_wxPyApp,
22951 _swigc__p_wxPyCommandEvent,
22952 _swigc__p_wxPyEvent,
22953 _swigc__p_wxPyGridCellAttrProvider,
22954 _swigc__p_wxPyGridCellEditor,
22955 _swigc__p_wxPyGridCellRenderer,
22956 _swigc__p_wxPyGridTableBase,
22957 _swigc__p_wxPyHtmlListBox,
22958 _swigc__p_wxPyImageHandler,
22959 _swigc__p_wxPyPanel,
22960 _swigc__p_wxPyPopupTransientWindow,
22961 _swigc__p_wxPyPreviewControlBar,
22962 _swigc__p_wxPyPreviewFrame,
22963 _swigc__p_wxPyPrintPreview,
22964 _swigc__p_wxPyPrintout,
22965 _swigc__p_wxPyScrolledWindow,
22966 _swigc__p_wxPySizer,
22967 _swigc__p_wxPyTaskBarIcon,
22968 _swigc__p_wxPyVListBox,
22969 _swigc__p_wxPyVScrolledWindow,
22970 _swigc__p_wxPyValidator,
22971 _swigc__p_wxPyWindow,
22972 _swigc__p_wxQueryLayoutInfoEvent,
22973 _swigc__p_wxQueryNewPaletteEvent,
22974 _swigc__p_wxRect,
22975 _swigc__p_wxSashEvent,
22976 _swigc__p_wxSashLayoutWindow,
22977 _swigc__p_wxSashWindow,
22978 _swigc__p_wxScrollEvent,
22979 _swigc__p_wxScrollWinEvent,
22980 _swigc__p_wxScrolledWindow,
22981 _swigc__p_wxSetCursorEvent,
22982 _swigc__p_wxShowEvent,
22983 _swigc__p_wxSimpleHtmlListBox,
22984 _swigc__p_wxSingleChoiceDialog,
22985 _swigc__p_wxSize,
22986 _swigc__p_wxSizeEvent,
22987 _swigc__p_wxSizer,
22988 _swigc__p_wxSizerItem,
22989 _swigc__p_wxSplashScreen,
22990 _swigc__p_wxSplashScreenWindow,
22991 _swigc__p_wxSplitterEvent,
22992 _swigc__p_wxSplitterWindow,
22993 _swigc__p_wxStaticBoxSizer,
22994 _swigc__p_wxStatusBar,
22995 _swigc__p_wxStdDialogButtonSizer,
22996 _swigc__p_wxString,
22997 _swigc__p_wxSysColourChangedEvent,
22998 _swigc__p_wxTGAHandler,
22999 _swigc__p_wxTIFFHandler,
23000 _swigc__p_wxTaskBarIconEvent,
23001 _swigc__p_wxTextEntryDialog,
23002 _swigc__p_wxTipWindow,
23003 _swigc__p_wxTopLevelWindow,
23004 _swigc__p_wxUpdateUIEvent,
23005 _swigc__p_wxValidator,
23006 _swigc__p_wxVisualAttributes,
23007 _swigc__p_wxWindow,
23008 _swigc__p_wxWindowCreateEvent,
23009 _swigc__p_wxWindowDestroyEvent,
23010 _swigc__p_wxXPMHandler,
23011 };
23012
23013
23014 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23015
23016 static swig_const_info swig_const_table[] = {
23017 {0, 0, 0, 0.0, 0, 0}};
23018
23019 #ifdef __cplusplus
23020 }
23021 #endif
23022 /* -----------------------------------------------------------------------------
23023 * Type initialization:
23024 * This problem is tough by the requirement that no dynamic
23025 * memory is used. Also, since swig_type_info structures store pointers to
23026 * swig_cast_info structures and swig_cast_info structures store pointers back
23027 * to swig_type_info structures, we need some lookup code at initialization.
23028 * The idea is that swig generates all the structures that are needed.
23029 * The runtime then collects these partially filled structures.
23030 * The SWIG_InitializeModule function takes these initial arrays out of
23031 * swig_module, and does all the lookup, filling in the swig_module.types
23032 * array with the correct data and linking the correct swig_cast_info
23033 * structures together.
23034 *
23035 * The generated swig_type_info structures are assigned staticly to an initial
23036 * array. We just loop though that array, and handle each type individually.
23037 * First we lookup if this type has been already loaded, and if so, use the
23038 * loaded structure instead of the generated one. Then we have to fill in the
23039 * cast linked list. The cast data is initially stored in something like a
23040 * two-dimensional array. Each row corresponds to a type (there are the same
23041 * number of rows as there are in the swig_type_initial array). Each entry in
23042 * a column is one of the swig_cast_info structures for that type.
23043 * The cast_initial array is actually an array of arrays, because each row has
23044 * a variable number of columns. So to actually build the cast linked list,
23045 * we find the array of casts associated with the type, and loop through it
23046 * adding the casts to the list. The one last trick we need to do is making
23047 * sure the type pointer in the swig_cast_info struct is correct.
23048 *
23049 * First off, we lookup the cast->type name to see if it is already loaded.
23050 * There are three cases to handle:
23051 * 1) If the cast->type has already been loaded AND the type we are adding
23052 * casting info to has not been loaded (it is in this module), THEN we
23053 * replace the cast->type pointer with the type pointer that has already
23054 * been loaded.
23055 * 2) If BOTH types (the one we are adding casting info to, and the
23056 * cast->type) are loaded, THEN the cast info has already been loaded by
23057 * the previous module so we just ignore it.
23058 * 3) Finally, if cast->type has not already been loaded, then we add that
23059 * swig_cast_info to the linked list (because the cast->type) pointer will
23060 * be correct.
23061 * ----------------------------------------------------------------------------- */
23062
23063 #ifdef __cplusplus
23064 extern "C" {
23065 #if 0
23066 } /* c-mode */
23067 #endif
23068 #endif
23069
23070 #if 0
23071 #define SWIGRUNTIME_DEBUG
23072 #endif
23073
23074 SWIGRUNTIME void
23075 SWIG_InitializeModule(void *clientdata) {
23076 size_t i;
23077 swig_module_info *module_head;
23078 static int init_run = 0;
23079
23080 clientdata = clientdata;
23081
23082 if (init_run) return;
23083 init_run = 1;
23084
23085 /* Initialize the swig_module */
23086 swig_module.type_initial = swig_type_initial;
23087 swig_module.cast_initial = swig_cast_initial;
23088
23089 /* Try and load any already created modules */
23090 module_head = SWIG_GetModule(clientdata);
23091 if (module_head) {
23092 swig_module.next = module_head->next;
23093 module_head->next = &swig_module;
23094 } else {
23095 /* This is the first module loaded */
23096 swig_module.next = &swig_module;
23097 SWIG_SetModule(clientdata, &swig_module);
23098 }
23099
23100 /* Now work on filling in swig_module.types */
23101 #ifdef SWIGRUNTIME_DEBUG
23102 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23103 #endif
23104 for (i = 0; i < swig_module.size; ++i) {
23105 swig_type_info *type = 0;
23106 swig_type_info *ret;
23107 swig_cast_info *cast;
23108
23109 #ifdef SWIGRUNTIME_DEBUG
23110 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23111 #endif
23112
23113 /* if there is another module already loaded */
23114 if (swig_module.next != &swig_module) {
23115 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23116 }
23117 if (type) {
23118 /* Overwrite clientdata field */
23119 #ifdef SWIGRUNTIME_DEBUG
23120 printf("SWIG_InitializeModule: found type %s\n", type->name);
23121 #endif
23122 if (swig_module.type_initial[i]->clientdata) {
23123 type->clientdata = swig_module.type_initial[i]->clientdata;
23124 #ifdef SWIGRUNTIME_DEBUG
23125 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23126 #endif
23127 }
23128 } else {
23129 type = swig_module.type_initial[i];
23130 }
23131
23132 /* Insert casting types */
23133 cast = swig_module.cast_initial[i];
23134 while (cast->type) {
23135 /* Don't need to add information already in the list */
23136 ret = 0;
23137 #ifdef SWIGRUNTIME_DEBUG
23138 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23139 #endif
23140 if (swig_module.next != &swig_module) {
23141 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23142 #ifdef SWIGRUNTIME_DEBUG
23143 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23144 #endif
23145 }
23146 if (ret) {
23147 if (type == swig_module.type_initial[i]) {
23148 #ifdef SWIGRUNTIME_DEBUG
23149 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23150 #endif
23151 cast->type = ret;
23152 ret = 0;
23153 } else {
23154 /* Check for casting already in the list */
23155 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23156 #ifdef SWIGRUNTIME_DEBUG
23157 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23158 #endif
23159 if (!ocast) ret = 0;
23160 }
23161 }
23162
23163 if (!ret) {
23164 #ifdef SWIGRUNTIME_DEBUG
23165 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23166 #endif
23167 if (type->cast) {
23168 type->cast->prev = cast;
23169 cast->next = type->cast;
23170 }
23171 type->cast = cast;
23172 }
23173 cast++;
23174 }
23175 /* Set entry in modules->types array equal to the type */
23176 swig_module.types[i] = type;
23177 }
23178 swig_module.types[i] = 0;
23179
23180 #ifdef SWIGRUNTIME_DEBUG
23181 printf("**** SWIG_InitializeModule: Cast List ******\n");
23182 for (i = 0; i < swig_module.size; ++i) {
23183 int j = 0;
23184 swig_cast_info *cast = swig_module.cast_initial[i];
23185 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23186 while (cast->type) {
23187 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23188 cast++;
23189 ++j;
23190 }
23191 printf("---- Total casts: %d\n",j);
23192 }
23193 printf("**** SWIG_InitializeModule: Cast List ******\n");
23194 #endif
23195 }
23196
23197 /* This function will propagate the clientdata field of type to
23198 * any new swig_type_info structures that have been added into the list
23199 * of equivalent types. It is like calling
23200 * SWIG_TypeClientData(type, clientdata) a second time.
23201 */
23202 SWIGRUNTIME void
23203 SWIG_PropagateClientData(void) {
23204 size_t i;
23205 swig_cast_info *equiv;
23206 static int init_run = 0;
23207
23208 if (init_run) return;
23209 init_run = 1;
23210
23211 for (i = 0; i < swig_module.size; i++) {
23212 if (swig_module.types[i]->clientdata) {
23213 equiv = swig_module.types[i]->cast;
23214 while (equiv) {
23215 if (!equiv->converter) {
23216 if (equiv->type && !equiv->type->clientdata)
23217 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23218 }
23219 equiv = equiv->next;
23220 }
23221 }
23222 }
23223 }
23224
23225 #ifdef __cplusplus
23226 #if 0
23227 {
23228 /* c-mode */
23229 #endif
23230 }
23231 #endif
23232
23233
23234
23235 #ifdef __cplusplus
23236 extern "C" {
23237 #endif
23238
23239 /* Python-specific SWIG API */
23240 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23241 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23242 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23243
23244 /* -----------------------------------------------------------------------------
23245 * global variable support code.
23246 * ----------------------------------------------------------------------------- */
23247
23248 typedef struct swig_globalvar {
23249 char *name; /* Name of global variable */
23250 PyObject *(*get_attr)(void); /* Return the current value */
23251 int (*set_attr)(PyObject *); /* Set the value */
23252 struct swig_globalvar *next;
23253 } swig_globalvar;
23254
23255 typedef struct swig_varlinkobject {
23256 PyObject_HEAD
23257 swig_globalvar *vars;
23258 } swig_varlinkobject;
23259
23260 SWIGINTERN PyObject *
23261 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23262 return PyString_FromString("<Swig global variables>");
23263 }
23264
23265 SWIGINTERN PyObject *
23266 swig_varlink_str(swig_varlinkobject *v) {
23267 PyObject *str = PyString_FromString("(");
23268 swig_globalvar *var;
23269 for (var = v->vars; var; var=var->next) {
23270 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23271 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23272 }
23273 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23274 return str;
23275 }
23276
23277 SWIGINTERN int
23278 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23279 PyObject *str = swig_varlink_str(v);
23280 fprintf(fp,"Swig global variables ");
23281 fprintf(fp,"%s\n", PyString_AsString(str));
23282 Py_DECREF(str);
23283 return 0;
23284 }
23285
23286 SWIGINTERN void
23287 swig_varlink_dealloc(swig_varlinkobject *v) {
23288 swig_globalvar *var = v->vars;
23289 while (var) {
23290 swig_globalvar *n = var->next;
23291 free(var->name);
23292 free(var);
23293 var = n;
23294 }
23295 }
23296
23297 SWIGINTERN PyObject *
23298 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23299 PyObject *res = NULL;
23300 swig_globalvar *var = v->vars;
23301 while (var) {
23302 if (strcmp(var->name,n) == 0) {
23303 res = (*var->get_attr)();
23304 break;
23305 }
23306 var = var->next;
23307 }
23308 if (res == NULL && !PyErr_Occurred()) {
23309 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23310 }
23311 return res;
23312 }
23313
23314 SWIGINTERN int
23315 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23316 int res = 1;
23317 swig_globalvar *var = v->vars;
23318 while (var) {
23319 if (strcmp(var->name,n) == 0) {
23320 res = (*var->set_attr)(p);
23321 break;
23322 }
23323 var = var->next;
23324 }
23325 if (res == 1 && !PyErr_Occurred()) {
23326 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23327 }
23328 return res;
23329 }
23330
23331 SWIGINTERN PyTypeObject*
23332 swig_varlink_type(void) {
23333 static char varlink__doc__[] = "Swig var link object";
23334 static PyTypeObject varlink_type;
23335 static int type_init = 0;
23336 if (!type_init) {
23337 const PyTypeObject tmp
23338 = {
23339 PyObject_HEAD_INIT(NULL)
23340 0, /* Number of items in variable part (ob_size) */
23341 (char *)"swigvarlink", /* Type name (tp_name) */
23342 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23343 0, /* Itemsize (tp_itemsize) */
23344 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23345 (printfunc) swig_varlink_print, /* Print (tp_print) */
23346 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23347 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23348 0, /* tp_compare */
23349 (reprfunc) swig_varlink_repr, /* tp_repr */
23350 0, /* tp_as_number */
23351 0, /* tp_as_sequence */
23352 0, /* tp_as_mapping */
23353 0, /* tp_hash */
23354 0, /* tp_call */
23355 (reprfunc)swig_varlink_str, /* tp_str */
23356 0, /* tp_getattro */
23357 0, /* tp_setattro */
23358 0, /* tp_as_buffer */
23359 0, /* tp_flags */
23360 varlink__doc__, /* tp_doc */
23361 0, /* tp_traverse */
23362 0, /* tp_clear */
23363 0, /* tp_richcompare */
23364 0, /* tp_weaklistoffset */
23365 #if PY_VERSION_HEX >= 0x02020000
23366 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23367 #endif
23368 #if PY_VERSION_HEX >= 0x02030000
23369 0, /* tp_del */
23370 #endif
23371 #ifdef COUNT_ALLOCS
23372 0,0,0,0 /* tp_alloc -> tp_next */
23373 #endif
23374 };
23375 varlink_type = tmp;
23376 varlink_type.ob_type = &PyType_Type;
23377 type_init = 1;
23378 }
23379 return &varlink_type;
23380 }
23381
23382 /* Create a variable linking object for use later */
23383 SWIGINTERN PyObject *
23384 SWIG_Python_newvarlink(void) {
23385 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23386 if (result) {
23387 result->vars = 0;
23388 }
23389 return ((PyObject*) result);
23390 }
23391
23392 SWIGINTERN void
23393 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23394 swig_varlinkobject *v = (swig_varlinkobject *) p;
23395 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23396 if (gv) {
23397 size_t size = strlen(name)+1;
23398 gv->name = (char *)malloc(size);
23399 if (gv->name) {
23400 strncpy(gv->name,name,size);
23401 gv->get_attr = get_attr;
23402 gv->set_attr = set_attr;
23403 gv->next = v->vars;
23404 }
23405 }
23406 v->vars = gv;
23407 }
23408
23409 SWIGINTERN PyObject *
23410 SWIG_globals() {
23411 static PyObject *_SWIG_globals = 0;
23412 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23413 return _SWIG_globals;
23414 }
23415
23416 /* -----------------------------------------------------------------------------
23417 * constants/methods manipulation
23418 * ----------------------------------------------------------------------------- */
23419
23420 /* Install Constants */
23421 SWIGINTERN void
23422 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23423 PyObject *obj = 0;
23424 size_t i;
23425 for (i = 0; constants[i].type; ++i) {
23426 switch(constants[i].type) {
23427 case SWIG_PY_POINTER:
23428 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23429 break;
23430 case SWIG_PY_BINARY:
23431 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23432 break;
23433 default:
23434 obj = 0;
23435 break;
23436 }
23437 if (obj) {
23438 PyDict_SetItemString(d, constants[i].name, obj);
23439 Py_DECREF(obj);
23440 }
23441 }
23442 }
23443
23444 /* -----------------------------------------------------------------------------*/
23445 /* Fix SwigMethods to carry the callback ptrs when needed */
23446 /* -----------------------------------------------------------------------------*/
23447
23448 SWIGINTERN void
23449 SWIG_Python_FixMethods(PyMethodDef *methods,
23450 swig_const_info *const_table,
23451 swig_type_info **types,
23452 swig_type_info **types_initial) {
23453 size_t i;
23454 for (i = 0; methods[i].ml_name; ++i) {
23455 const char *c = methods[i].ml_doc;
23456 if (c && (c = strstr(c, "swig_ptr: "))) {
23457 int j;
23458 swig_const_info *ci = 0;
23459 const char *name = c + 10;
23460 for (j = 0; const_table[j].type; ++j) {
23461 if (strncmp(const_table[j].name, name,
23462 strlen(const_table[j].name)) == 0) {
23463 ci = &(const_table[j]);
23464 break;
23465 }
23466 }
23467 if (ci) {
23468 size_t shift = (ci->ptype) - types;
23469 swig_type_info *ty = types_initial[shift];
23470 size_t ldoc = (c - methods[i].ml_doc);
23471 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23472 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23473 if (ndoc) {
23474 char *buff = ndoc;
23475 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23476 if (ptr) {
23477 strncpy(buff, methods[i].ml_doc, ldoc);
23478 buff += ldoc;
23479 strncpy(buff, "swig_ptr: ", 10);
23480 buff += 10;
23481 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23482 methods[i].ml_doc = ndoc;
23483 }
23484 }
23485 }
23486 }
23487 }
23488 }
23489
23490 #ifdef __cplusplus
23491 }
23492 #endif
23493
23494 /* -----------------------------------------------------------------------------*
23495 * Partial Init method
23496 * -----------------------------------------------------------------------------*/
23497
23498 #ifdef __cplusplus
23499 extern "C"
23500 #endif
23501 SWIGEXPORT void SWIG_init(void) {
23502 PyObject *m, *d;
23503
23504 /* Fix SwigMethods to carry the callback ptrs when needed */
23505 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23506
23507 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23508 d = PyModule_GetDict(m);
23509
23510 SWIG_InitializeModule(0);
23511 SWIG_InstallConstants(d,swig_const_table);
23512
23513
23514 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23515 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23516 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23517 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23518 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23519 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23520 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23521 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23522 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23523 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23524 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23525 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23526 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23527 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23528 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23529 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23530 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23531 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23532 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23533 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23534 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23535 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23536 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23537 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23538 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23539 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23540 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23541 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23542 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23543 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23544 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23545 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23546 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23547 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23548 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23549 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23550 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23551 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23552 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23553 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23554 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23555 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23556 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23557 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23558 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23559 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23560 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23561 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23562 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23563 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23564 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23565 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23566 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23567 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23568 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23569 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23570 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23571
23572
23573 }
23574
wxWidgets (Impactor)