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


0980cb06feb6d754254010c3d33369a02e644f05
[wxWidgets.git] / wxPython / src / mac / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMoveEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[104]
2571 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNcPaintEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNotifyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxPCXHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNGHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNMHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialog swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPanel swig_types[117]
2584 #define SWIGTYPE_p_wxPaperSize swig_types[118]
2585 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[119]
2586 #define SWIGTYPE_p_wxPen swig_types[120]
2587 #define SWIGTYPE_p_wxPoint swig_types[121]
2588 #define SWIGTYPE_p_wxPopupWindow swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewCanvas swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewControlBar swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewFrame swig_types[125]
2592 #define SWIGTYPE_p_wxPrintData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialog swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialogData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintPreview swig_types[129]
2596 #define SWIGTYPE_p_wxPrinter swig_types[130]
2597 #define SWIGTYPE_p_wxProgressDialog swig_types[131]
2598 #define SWIGTYPE_p_wxPyApp swig_types[132]
2599 #define SWIGTYPE_p_wxPyCommandEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridTableBase swig_types[138]
2605 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[139]
2606 #define SWIGTYPE_p_wxPyImageHandler swig_types[140]
2607 #define SWIGTYPE_p_wxPyPanel swig_types[141]
2608 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintPreview swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintout swig_types[146]
2613 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[147]
2614 #define SWIGTYPE_p_wxPySizer swig_types[148]
2615 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[149]
2616 #define SWIGTYPE_p_wxPyVListBox swig_types[150]
2617 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPyValidator swig_types[152]
2619 #define SWIGTYPE_p_wxPyWindow swig_types[153]
2620 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[154]
2621 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[155]
2622 #define SWIGTYPE_p_wxRect swig_types[156]
2623 #define SWIGTYPE_p_wxSashEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[158]
2625 #define SWIGTYPE_p_wxSashWindow swig_types[159]
2626 #define SWIGTYPE_p_wxScrollEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrollWinEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrolledWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSetCursorEvent swig_types[163]
2630 #define SWIGTYPE_p_wxShowEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[165]
2632 #define SWIGTYPE_p_wxSizeEvent swig_types[166]
2633 #define SWIGTYPE_p_wxSizer swig_types[167]
2634 #define SWIGTYPE_p_wxSizerItem swig_types[168]
2635 #define SWIGTYPE_p_wxSplashScreen swig_types[169]
2636 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[170]
2637 #define SWIGTYPE_p_wxSplitterEvent swig_types[171]
2638 #define SWIGTYPE_p_wxSplitterWindow swig_types[172]
2639 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[173]
2640 #define SWIGTYPE_p_wxStatusBar swig_types[174]
2641 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[175]
2642 #define SWIGTYPE_p_wxString swig_types[176]
2643 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[177]
2644 #define SWIGTYPE_p_wxTIFFHandler swig_types[178]
2645 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[179]
2646 #define SWIGTYPE_p_wxTextEntryDialog swig_types[180]
2647 #define SWIGTYPE_p_wxTipWindow swig_types[181]
2648 #define SWIGTYPE_p_wxTopLevelWindow swig_types[182]
2649 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[183]
2650 #define SWIGTYPE_p_wxValidator swig_types[184]
2651 #define SWIGTYPE_p_wxVisualAttributes swig_types[185]
2652 #define SWIGTYPE_p_wxWindow swig_types[186]
2653 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[187]
2654 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[188]
2655 #define SWIGTYPE_p_wxXPMHandler swig_types[189]
2656 static swig_type_info *swig_types[191];
2657 static swig_module_info swig_module = {swig_types, 190, 0, 0, 0, 0};
2658 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2659 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2660
2661 /* -------- TYPES TABLE (END) -------- */
2662
2663 #if (PY_VERSION_HEX <= 0x02000000)
2664 # if !defined(SWIG_PYTHON_CLASSIC)
2665 # error "This python version requires to use swig with the '-classic' option"
2666 # endif
2667 #endif
2668 #if (PY_VERSION_HEX <= 0x02020000)
2669 # error "This python version requires to use swig with the '-nomodern' option"
2670 #endif
2671 #if (PY_VERSION_HEX <= 0x02020000)
2672 # error "This python version requires to use swig with the '-nomodernargs' option"
2673 #endif
2674 #ifndef METH_O
2675 # error "This python version requires to use swig with the '-nofastunpack' option"
2676 #endif
2677
2678 /*-----------------------------------------------
2679 @(target):= _grid.so
2680 ------------------------------------------------*/
2681 #define SWIG_init init_grid
2682
2683 #define SWIG_name "_grid"
2684
2685 #define SWIGVERSION 0x010329
2686
2687
2688 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2689 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2690
2691
2692 #include <stdexcept>
2693
2694
2695 namespace swig {
2696 class PyObject_ptr {
2697 protected:
2698 PyObject *_obj;
2699
2700 public:
2701 PyObject_ptr() :_obj(0)
2702 {
2703 }
2704
2705 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2706 {
2707 Py_XINCREF(_obj);
2708 }
2709
2710 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2711 {
2712 if (initial_ref) Py_XINCREF(_obj);
2713 }
2714
2715 PyObject_ptr & operator=(const PyObject_ptr& item)
2716 {
2717 Py_XINCREF(item._obj);
2718 Py_XDECREF(_obj);
2719 _obj = item._obj;
2720 return *this;
2721 }
2722
2723 ~PyObject_ptr()
2724 {
2725 Py_XDECREF(_obj);
2726 }
2727
2728 operator PyObject *() const
2729 {
2730 return _obj;
2731 }
2732
2733 PyObject *operator->() const
2734 {
2735 return _obj;
2736 }
2737 };
2738 }
2739
2740
2741 namespace swig {
2742 struct PyObject_var : PyObject_ptr {
2743 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2744
2745 PyObject_var & operator = (PyObject* obj)
2746 {
2747 Py_XDECREF(_obj);
2748 _obj = obj;
2749 return *this;
2750 }
2751 };
2752 }
2753
2754
2755 #include "wx/wxPython/wxPython.h"
2756 #include "wx/wxPython/pyclasses.h"
2757 #include "wx/wxPython/printfw.h"
2758
2759 #include <wx/grid.h>
2760 #include <wx/generic/gridctrl.h>
2761
2762
2763 static const wxString wxPyEmptyString(wxEmptyString);
2764 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2765 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2766
2767
2768 #define wxPyMake_TEMPLATE(TYPE) \
2769 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2770 PyObject* target = NULL; \
2771 if (source) { \
2772 /* Check if there is already a pointer to a Python object in the \
2773 OOR data that we can use. */ \
2774 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2775 if (data) { \
2776 target = data->m_obj; \
2777 if (target) \
2778 Py_INCREF(target); \
2779 } \
2780 /* Otherwise make a new wrapper for it the old fashioned way and \
2781 give it the OOR treatment */ \
2782 if (! target) { \
2783 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2784 if (target) \
2785 source->SetClientObject(new wxPyOORClientData(target)); \
2786 } \
2787 } else { /* source was NULL so return None. */ \
2788 Py_INCREF(Py_None); target = Py_None; \
2789 } \
2790 return target; \
2791 } \
2792
2793
2794 wxPyMake_TEMPLATE(wxGridCellRenderer)
2795 wxPyMake_TEMPLATE(wxGridCellEditor)
2796 wxPyMake_TEMPLATE(wxGridCellAttr)
2797 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2798 wxPyMake_TEMPLATE(wxGridTableBase)
2799
2800
2801
2802 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2803 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2804 wxGridCellAttr* rval = NULL; \
2805 bool found; \
2806 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2807 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2808 PyObject* ro; \
2809 wxGridCellAttr* ptr; \
2810 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2811 if (ro) { \
2812 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2813 rval = ptr; \
2814 Py_DECREF(ro); \
2815 } \
2816 } \
2817 wxPyEndBlockThreads(blocked); \
2818 if (! found) \
2819 rval = PCLASS::CBNAME(a, b, c); \
2820 return rval; \
2821 }
2822
2823
2824 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2825 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2827 bool found; \
2828 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2829 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2830 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2831 Py_DECREF(obj); \
2832 } \
2833 wxPyEndBlockThreads(blocked); \
2834 if (! found) \
2835 PCLASS::CBNAME(attr, a, b); \
2836 }
2837
2838
2839
2840 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2841 void CBNAME(wxGridCellAttr *attr, int val) { \
2842 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2843 bool found; \
2844 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2845 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2847 Py_DECREF(obj); \
2848 } \
2849 wxPyEndBlockThreads(blocked); \
2850 if (! found) \
2851 PCLASS::CBNAME(attr, val); \
2852 }
2853
2854
2855
2856 #define PYCALLBACK_INT__pure(CBNAME) \
2857 int CBNAME() { \
2858 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2859 int rval = 0; \
2860 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2861 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2862 wxPyEndBlockThreads(blocked); \
2863 return rval; \
2864 }
2865
2866
2867
2868 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2869 bool CBNAME(int a, int b) { \
2870 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2871 bool rval = 0; \
2872 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2873 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2874 wxPyEndBlockThreads(blocked); \
2875 return rval; \
2876 }
2877
2878
2879 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2880 wxString CBNAME(int a, int b) { \
2881 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2882 wxString rval; \
2883 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2884 PyObject* ro; \
2885 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2886 if (ro) { \
2887 rval = Py2wxString(ro); \
2888 Py_DECREF(ro); \
2889 } \
2890 } \
2891 wxPyEndBlockThreads(blocked); \
2892 return rval; \
2893 }
2894
2895
2896 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2897 void CBNAME(int a, int b, const wxString& c) { \
2898 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2899 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2900 PyObject* s = wx2PyString(c); \
2901 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2902 Py_DECREF(s); \
2903 } \
2904 wxPyEndBlockThreads(blocked); \
2905 }
2906
2907
2908 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2909 wxString CBNAME(int a, int b) { \
2910 bool found; \
2911 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2912 wxString rval; \
2913 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2914 PyObject* ro; \
2915 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2916 if (ro) { \
2917 rval = Py2wxString(ro); \
2918 Py_DECREF(ro); \
2919 } \
2920 } \
2921 wxPyEndBlockThreads(blocked); \
2922 if (! found) \
2923 rval = PCLASS::CBNAME(a, b); \
2924 return rval; \
2925 }
2926
2927
2928 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2929 bool CBNAME(int a, int b, const wxString& c) { \
2930 bool rval = 0; \
2931 bool found; \
2932 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2933 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2934 PyObject* s = wx2PyString(c); \
2935 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2936 Py_DECREF(s); \
2937 } \
2938 wxPyEndBlockThreads(blocked); \
2939 if (! found) \
2940 rval = PCLASS::CBNAME(a,b,c); \
2941 return rval; \
2942 }
2943
2944
2945
2946
2947 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2948 long CBNAME(int a, int b) { \
2949 long rval; \
2950 bool found; \
2951 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2952 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2953 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2954 wxPyEndBlockThreads(blocked); \
2955 if (! found) \
2956 rval = PCLASS::CBNAME(a,b); \
2957 return rval; \
2958 }
2959
2960
2961 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2962 bool CBNAME(int a, int b) { \
2963 bool rval = 0; \
2964 bool found; \
2965 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2966 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2967 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2968 wxPyEndBlockThreads(blocked); \
2969 if (! found) \
2970 rval = PCLASS::CBNAME(a,b); \
2971 return rval; \
2972 }
2973
2974
2975
2976 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2977 double CBNAME(int a, int b) { \
2978 bool found; \
2979 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2980 double rval; \
2981 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2982 PyObject* ro; \
2983 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2984 if (ro) { \
2985 PyObject* str = PyObject_Str(ro); \
2986 rval = PyFloat_AsDouble(str); \
2987 Py_DECREF(ro); Py_DECREF(str); \
2988 } \
2989 } \
2990 wxPyEndBlockThreads(blocked); \
2991 if (! found) \
2992 rval = PCLASS::CBNAME(a, b); \
2993 return rval; \
2994 }
2995
2996
2997
2998 #define PYCALLBACK__(PCLASS, CBNAME) \
2999 void CBNAME() { \
3000 bool found; \
3001 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3002 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3003 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3004 wxPyEndBlockThreads(blocked); \
3005 if (! found) \
3006 PCLASS::CBNAME(); \
3007 }
3008
3009
3010
3011 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3012 bool CBNAME(size_t a, size_t b) { \
3013 bool rval = 0; \
3014 bool found; \
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3016 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3017 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3018 wxPyEndBlockThreads(blocked); \
3019 if (! found) \
3020 rval = PCLASS::CBNAME(a,b); \
3021 return rval; \
3022 }
3023
3024
3025
3026 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3027 bool CBNAME(size_t a) { \
3028 bool rval = 0; \
3029 bool found; \
3030 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3031 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3032 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3033 wxPyEndBlockThreads(blocked); \
3034 if (! found) \
3035 rval = PCLASS::CBNAME(a); \
3036 return rval; \
3037 }
3038
3039
3040 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3041 wxString CBNAME(int a) { \
3042 bool found; \
3043 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3044 wxString rval; \
3045 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3046 PyObject* ro; \
3047 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3048 if (ro) { \
3049 rval = Py2wxString(ro); \
3050 Py_DECREF(ro); \
3051 } \
3052 } \
3053 wxPyEndBlockThreads(blocked); \
3054 if (! found) \
3055 rval = PCLASS::CBNAME(a); \
3056 return rval; \
3057 }
3058
3059
3060 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3061 void CBNAME(int a, const wxString& c) { \
3062 bool found; \
3063 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3064 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3065 PyObject* s = wx2PyString(c); \
3066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3067 Py_DECREF(s); \
3068 } \
3069 wxPyEndBlockThreads(blocked); \
3070 if (! found) \
3071 PCLASS::CBNAME(a,c); \
3072 }
3073
3074
3075
3076
3077 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3078 bool CBNAME() { \
3079 bool rval = 0; \
3080 bool found; \
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3082 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3083 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3084 wxPyEndBlockThreads(blocked); \
3085 if (! found) \
3086 rval = PCLASS::CBNAME(); \
3087 return rval; \
3088 }
3089
3090
3091
3092 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3093 void CBNAME(size_t a, int b) { \
3094 bool found; \
3095 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3096 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3097 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3098 wxPyEndBlockThreads(blocked); \
3099 if (! found) \
3100 PCLASS::CBNAME(a,b); \
3101 }
3102
3103
3104
3105
3106 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3107 void CBNAME(int a, int b, long c) { \
3108 bool found; \
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3110 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3111 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3112 wxPyEndBlockThreads(blocked); \
3113 if (! found) \
3114 PCLASS::CBNAME(a,b,c); \
3115 }
3116
3117
3118
3119
3120 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3121 void CBNAME(int a, int b, double c) { \
3122 bool found; \
3123 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3124 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3125 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3126 wxPyEndBlockThreads(blocked); \
3127 if (! found) \
3128 PCLASS::CBNAME(a,b,c); \
3129 }
3130
3131
3132
3133 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3134 void CBNAME(int a, int b, bool c) { \
3135 bool found; \
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3137 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3138 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3139 wxPyEndBlockThreads(blocked); \
3140 if (! found) \
3141 PCLASS::CBNAME(a,b,c); \
3142 }
3143
3144
3145
3146
3147
3148 SWIGINTERN swig_type_info*
3149 SWIG_pchar_descriptor()
3150 {
3151 static int init = 0;
3152 static swig_type_info* info = 0;
3153 if (!init) {
3154 info = SWIG_TypeQuery("_p_char");
3155 init = 1;
3156 }
3157 return info;
3158 }
3159
3160
3161 SWIGINTERNINLINE PyObject *
3162 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3163 {
3164 if (carray) {
3165 if (size > INT_MAX) {
3166 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3167 return pchar_descriptor ?
3168 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3169 } else {
3170 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3171 }
3172 } else {
3173 return SWIG_Py_Void();
3174 }
3175 }
3176
3177
3178 SWIGINTERNINLINE PyObject *
3179 SWIG_FromCharPtr(const char *cptr)
3180 {
3181 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3182 }
3183
3184
3185 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3186 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3187 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3188 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3189 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3190 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3191 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3192 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3193 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3194 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3195
3196
3197 #define SWIG_From_long PyInt_FromLong
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_int (int value)
3202 {
3203 return SWIG_From_long (value);
3204 }
3205
3206 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3207 if (!self->GetClientObject())
3208 self->SetClientObject(new wxPyOORClientData(_self));
3209 }
3210 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3211 }
3212
3213 class wxPyGridCellRenderer : public wxGridCellRenderer
3214 {
3215 public:
3216 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3217
3218 // Implement Python callback aware virtual methods
3219 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3220 wxDC& dc, const wxRect& rect,
3221 int row, int col, bool isSelected) {
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3224 PyObject* go = wxPyMake_wxObject(&grid,false);
3225 PyObject* dco = wxPyMake_wxObject(&dc,false);
3226 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3227 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3228
3229 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3230 row, col, isSelected));
3231 Py_DECREF(go);
3232 Py_DECREF(ao);
3233 Py_DECREF(dco);
3234 Py_DECREF(ro);
3235 }
3236 wxPyEndBlockThreads(blocked);
3237 }
3238
3239 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3240 int row, int col) {
3241 wxSize rval;
3242 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3243 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3244 PyObject* ro;
3245 wxSize* ptr;
3246 PyObject* go = wxPyMake_wxObject(&grid,false);
3247 PyObject* dco = wxPyMake_wxObject(&dc,false);
3248 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3249
3250 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3251 go, ao, dco,
3252 row, col));
3253 Py_DECREF(go);
3254 Py_DECREF(ao);
3255 Py_DECREF(dco);
3256
3257 if (ro) {
3258 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3259 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3260 rval = *ptr;
3261 }
3262 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3263 PyObject* o1 = PySequence_GetItem(ro, 0);
3264 PyObject* o2 = PySequence_GetItem(ro, 1);
3265 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3266 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3267 else
3268 PyErr_SetString(PyExc_TypeError, errmsg);
3269 Py_DECREF(o1);
3270 Py_DECREF(o2);
3271 }
3272 else {
3273 PyErr_SetString(PyExc_TypeError, errmsg);
3274 }
3275 Py_DECREF(ro);
3276 }
3277 }
3278 wxPyEndBlockThreads(blocked);
3279 return rval;
3280 }
3281
3282
3283 wxGridCellRenderer *Clone() const {
3284 wxGridCellRenderer* rval = NULL;
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3287 PyObject* ro;
3288 wxGridCellRenderer* ptr;
3289 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3290 if (ro) {
3291 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3292 rval = ptr;
3293 Py_DECREF(ro);
3294 }
3295 }
3296 wxPyEndBlockThreads(blocked);
3297 return rval;
3298 }
3299
3300 DEC_PYCALLBACK__STRING(SetParameters);
3301
3302 PYPRIVATE;
3303 };
3304
3305 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3306
3307
3308
3309 #include <limits.h>
3310 #ifndef LLONG_MIN
3311 # define LLONG_MIN LONG_LONG_MIN
3312 #endif
3313 #ifndef LLONG_MAX
3314 # define LLONG_MAX LONG_LONG_MAX
3315 #endif
3316 #ifndef ULLONG_MAX
3317 # define ULLONG_MAX ULONG_LONG_MAX
3318 #endif
3319
3320
3321 SWIGINTERN int
3322 SWIG_AsVal_long (PyObject* obj, long* val)
3323 {
3324 if (PyNumber_Check(obj)) {
3325 if (val) *val = PyInt_AsLong(obj);
3326 return SWIG_OK;
3327 }
3328 return SWIG_TypeError;
3329 }
3330
3331
3332 SWIGINTERN int
3333 SWIG_AsVal_int (PyObject * obj, int *val)
3334 {
3335 long v;
3336 int res = SWIG_AsVal_long (obj, &v);
3337 if (SWIG_IsOK(res)) {
3338 if ((v < INT_MIN || v > INT_MAX)) {
3339 return SWIG_OverflowError;
3340 } else {
3341 if (val) *val = static_cast< int >(v);
3342 }
3343 }
3344 return res;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_bool (PyObject *obj, bool *val)
3350 {
3351 if (obj == Py_True) {
3352 if (val) *val = true;
3353 return SWIG_OK;
3354 } else if (obj == Py_False) {
3355 if (val) *val = false;
3356 return SWIG_OK;
3357 } else {
3358 long v = 0;
3359 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3360 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3361 return res;
3362 }
3363 }
3364
3365
3366 class wxPyGridCellEditor : public wxGridCellEditor
3367 {
3368 public:
3369 wxPyGridCellEditor() : wxGridCellEditor() {}
3370
3371 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3373 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3374 PyObject* po = wxPyMake_wxObject(parent,false);
3375 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3376
3377 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3378 Py_DECREF(po);
3379 Py_DECREF(eo);
3380 }
3381 wxPyEndBlockThreads(blocked);
3382 }
3383
3384
3385 void BeginEdit(int row, int col, wxGrid* grid) {
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3388 PyObject* go = wxPyMake_wxObject(grid,false);
3389 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3390 Py_DECREF(go);
3391 }
3392 wxPyEndBlockThreads(blocked);
3393 }
3394
3395
3396 bool EndEdit(int row, int col, wxGrid* grid) {
3397 bool rv = false;
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3400 PyObject* go = wxPyMake_wxObject(grid,false);
3401 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3402 Py_DECREF(go);
3403 }
3404 wxPyEndBlockThreads(blocked);
3405 return rv;
3406 }
3407
3408
3409 wxGridCellEditor* Clone() const {
3410 wxGridCellEditor* rval = NULL;
3411 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3412 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3413 PyObject* ro;
3414 wxGridCellEditor* ptr;
3415 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3416 if (ro) {
3417 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3418 rval = ptr;
3419 Py_DECREF(ro);
3420 }
3421 }
3422 wxPyEndBlockThreads(blocked);
3423 return rval;
3424 }
3425
3426
3427 void Show(bool show, wxGridCellAttr *attr) {
3428 bool found;
3429 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3430 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3431 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3432 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3433 Py_DECREF(ao);
3434 }
3435 wxPyEndBlockThreads(blocked);
3436 if (! found)
3437 wxGridCellEditor::Show(show, attr);
3438 }
3439
3440
3441 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3442 bool found;
3443 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3444 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3445 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3446 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3447
3448 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3449
3450 Py_DECREF(ro);
3451 Py_DECREF(ao);
3452 }
3453 wxPyEndBlockThreads(blocked);
3454 if (! found)
3455 wxGridCellEditor::PaintBackground(rectCell, attr);
3456 }
3457
3458
3459 DEC_PYCALLBACK___pure(Reset);
3460 DEC_PYCALLBACK__constany(SetSize, wxRect);
3461 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3462 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3463 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3464 DEC_PYCALLBACK__(StartingClick);
3465 DEC_PYCALLBACK__(Destroy);
3466 DEC_PYCALLBACK__STRING(SetParameters);
3467 DEC_PYCALLBACK_STRING__constpure(GetValue);
3468
3469 PYPRIVATE;
3470 };
3471
3472
3473 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3474 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3475 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3476 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3477 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3478 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3479 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3480 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3481 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3482
3483
3484 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3485 if (!self->GetClientObject())
3486 self->SetClientObject(new wxPyOORClientData(_self));
3487 }
3488 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3489 }
3490 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3491 if (!self->GetClientObject())
3492 self->SetClientObject(new wxPyOORClientData(_self));
3493 }
3494
3495 SWIGINTERN int
3496 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3497 {
3498 long v = 0;
3499 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3500 return SWIG_TypeError;
3501 }
3502 else if (val)
3503 *val = (unsigned long)v;
3504 return SWIG_OK;
3505 }
3506
3507
3508 SWIGINTERNINLINE int
3509 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3510 {
3511 unsigned long v;
3512 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3513 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3514 return res;
3515 }
3516
3517
3518 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3519 {
3520 public:
3521 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3522
3523 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3524 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3525 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3526 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3527
3528 PYPRIVATE;
3529 };
3530
3531 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3532 if (!self->GetClientObject())
3533 self->SetClientObject(new wxPyOORClientData(_self));
3534 }
3535
3536 #define SWIG_From_double PyFloat_FromDouble
3537
3538
3539 SWIGINTERN int
3540 SWIG_AsVal_double (PyObject *obj, double* val)
3541 {
3542 if (PyNumber_Check(obj)) {
3543 if (val) *val = PyFloat_AsDouble(obj);
3544 return SWIG_OK;
3545 }
3546 return SWIG_TypeError;
3547 }
3548
3549
3550 class wxPyGridTableBase : public wxGridTableBase
3551 {
3552 public:
3553 wxPyGridTableBase() : wxGridTableBase() {}
3554
3555 PYCALLBACK_INT__pure(GetNumberRows);
3556 PYCALLBACK_INT__pure(GetNumberCols);
3557 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3558 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3559 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3560 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3561 PYCALLBACK__(wxGridTableBase, Clear);
3562 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3563 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3564 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3565 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3566 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3567 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3568 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3569 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3570 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3571 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3572 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3573 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3574 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3575 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3576 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3577
3578
3579 wxString GetValue(int row, int col) {
3580 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3581 wxString rval;
3582 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3583 PyObject* ro;
3584 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3585 if (ro) {
3586 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3587 PyObject* old = ro;
3588 ro = PyObject_Str(ro);
3589 Py_DECREF(old);
3590 }
3591 rval = Py2wxString(ro);
3592 Py_DECREF(ro);
3593 }
3594 }
3595 wxPyEndBlockThreads(blocked);
3596 return rval;
3597 }
3598
3599 void SetValue(int row, int col, const wxString& val) {
3600 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3601 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3602 PyObject* s = wx2PyString(val);
3603 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3604 Py_DECREF(s);
3605 }
3606 wxPyEndBlockThreads(blocked);
3607 }
3608
3609
3610 // Map the Get/Set methods for the standard non-string types to
3611 // the GetValue and SetValue python methods.
3612 long GetValueAsLong( int row, int col ) {
3613 long rval = 0;
3614 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3615 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3616 PyObject* ro;
3617 PyObject* num;
3618 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3619 if (ro && PyNumber_Check(ro)) {
3620 num = PyNumber_Int(ro);
3621 if (num) {
3622 rval = PyInt_AsLong(num);
3623 Py_DECREF(num);
3624 }
3625 Py_DECREF(ro);
3626 }
3627 }
3628 wxPyEndBlockThreads(blocked);
3629 return rval;
3630 }
3631
3632 double GetValueAsDouble( int row, int col ) {
3633 double rval = 0.0;
3634 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3635 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3636 PyObject* ro;
3637 PyObject* num;
3638 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3639 if (ro && PyNumber_Check(ro)) {
3640 num = PyNumber_Float(ro);
3641 if (num) {
3642 rval = PyFloat_AsDouble(num);
3643 Py_DECREF(num);
3644 }
3645 Py_DECREF(ro);
3646 }
3647 }
3648 wxPyEndBlockThreads(blocked);
3649 return rval;
3650 }
3651
3652 bool GetValueAsBool( int row, int col ) {
3653 return (bool)GetValueAsLong(row, col);
3654 }
3655
3656 void SetValueAsLong( int row, int col, long value ) {
3657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3658 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3659 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3660 }
3661 wxPyEndBlockThreads(blocked);
3662 }
3663
3664 void SetValueAsDouble( int row, int col, double value ) {
3665 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3666 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3667 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3668 }
3669 wxPyEndBlockThreads(blocked);
3670 }
3671
3672 void SetValueAsBool( int row, int col, bool value ) {
3673 SetValueAsLong( row, col, (long)value );
3674 }
3675
3676
3677 PYPRIVATE;
3678 };
3679
3680 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3681
3682 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3683
3684 if (source == Py_None) {
3685 **obj = wxGridCellCoords(-1,-1);
3686 return true;
3687 }
3688
3689 // If source is an object instance then it may already be the right type
3690 if (wxPySwigInstance_Check(source)) {
3691 wxGridCellCoords* ptr;
3692 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3693 goto error;
3694 *obj = ptr;
3695 return true;
3696 }
3697 // otherwise a 2-tuple of integers is expected
3698 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3699 PyObject* o1 = PySequence_GetItem(source, 0);
3700 PyObject* o2 = PySequence_GetItem(source, 1);
3701 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3702 Py_DECREF(o1);
3703 Py_DECREF(o2);
3704 goto error;
3705 }
3706 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3707 Py_DECREF(o1);
3708 Py_DECREF(o2);
3709 return true;
3710 }
3711
3712 error:
3713 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3714 return false;
3715 }
3716
3717
3718 bool wxGridCellCoords_typecheck(PyObject* source) {
3719 void* ptr;
3720
3721 if (wxPySwigInstance_Check(source) &&
3722 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3723 return true;
3724
3725 PyErr_Clear();
3726 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3727 return true;
3728
3729 return false;
3730 }
3731
3732
3733 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3734 {
3735 PyObject* list = PyList_New(0);
3736 size_t idx;
3737 for (idx = 0; idx < source.GetCount(); idx += 1) {
3738 wxGridCellCoords& coord = source.Item(idx);
3739 PyObject* tup = PyTuple_New(2);
3740 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3741 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3742 PyList_Append(list, tup);
3743 Py_DECREF(tup);
3744 }
3745 return list;
3746 }
3747
3748 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3749 wxGridCellCoords temp, *obj = &temp;
3750 if ( other == Py_None ) return false;
3751 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3752 PyErr_Clear();
3753 return false;
3754 }
3755 return self->operator==(*obj);
3756 }
3757 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3758 wxGridCellCoords temp, *obj = &temp;
3759 if ( other == Py_None ) return true;
3760 if ( ! wxGridCellCoords_helper(other, &obj)) {
3761 PyErr_Clear();
3762 return true;
3763 }
3764 return self->operator!=(*obj);
3765 }
3766 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3767 PyObject* tup = PyTuple_New(2);
3768 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3769 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3770 return tup;
3771 }
3772
3773 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3774
3775 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3776 wxGridCellCoords rv;
3777 self->XYToCell(x, y, rv);
3778 return rv;
3779 }
3780 #ifdef __cplusplus
3781 extern "C" {
3782 #endif
3783 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3784 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3785 return 1;
3786 }
3787
3788
3789 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3790 PyObject *pyobj = 0;
3791
3792 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3793 return pyobj;
3794 }
3795
3796
3797 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3798 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3799 return 1;
3800 }
3801
3802
3803 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3804 PyObject *pyobj = 0;
3805
3806 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3807 return pyobj;
3808 }
3809
3810
3811 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj = 0;
3813 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3814 PyObject *arg2 = (PyObject *) 0 ;
3815 void *argp1 = 0 ;
3816 int res1 = 0 ;
3817 PyObject * obj0 = 0 ;
3818 PyObject * obj1 = 0 ;
3819 char * kwnames[] = {
3820 (char *) "self",(char *) "_self", NULL
3821 };
3822
3823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3825 if (!SWIG_IsOK(res1)) {
3826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3827 }
3828 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3829 arg2 = obj1;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 wxGridCellWorker__setOORInfo(arg1,arg2);
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 resultobj = SWIG_Py_Void();
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3844 PyObject *resultobj = 0;
3845 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3846 void *argp1 = 0 ;
3847 int res1 = 0 ;
3848 PyObject *swig_obj[1] ;
3849
3850 if (!args) SWIG_fail;
3851 swig_obj[0] = args;
3852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3853 if (!SWIG_IsOK(res1)) {
3854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3855 }
3856 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3857 {
3858 PyThreadState* __tstate = wxPyBeginAllowThreads();
3859 delete_wxGridCellWorker(arg1);
3860
3861 wxPyEndAllowThreads(__tstate);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 resultobj = SWIG_Py_Void();
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj = 0;
3873 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3874 wxString *arg2 = 0 ;
3875 void *argp1 = 0 ;
3876 int res1 = 0 ;
3877 bool temp2 = false ;
3878 PyObject * obj0 = 0 ;
3879 PyObject * obj1 = 0 ;
3880 char * kwnames[] = {
3881 (char *) "self",(char *) "params", NULL
3882 };
3883
3884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3886 if (!SWIG_IsOK(res1)) {
3887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3888 }
3889 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3890 {
3891 arg2 = wxString_in_helper(obj1);
3892 if (arg2 == NULL) SWIG_fail;
3893 temp2 = true;
3894 }
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 (arg1)->SetParameters((wxString const &)*arg2);
3898 wxPyEndAllowThreads(__tstate);
3899 if (PyErr_Occurred()) SWIG_fail;
3900 }
3901 resultobj = SWIG_Py_Void();
3902 {
3903 if (temp2)
3904 delete arg2;
3905 }
3906 return resultobj;
3907 fail:
3908 {
3909 if (temp2)
3910 delete arg2;
3911 }
3912 return NULL;
3913 }
3914
3915
3916 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3917 PyObject *resultobj = 0;
3918 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3919 void *argp1 = 0 ;
3920 int res1 = 0 ;
3921 PyObject *swig_obj[1] ;
3922
3923 if (!args) SWIG_fail;
3924 swig_obj[0] = args;
3925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3926 if (!SWIG_IsOK(res1)) {
3927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3928 }
3929 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3930 {
3931 PyThreadState* __tstate = wxPyBeginAllowThreads();
3932 (arg1)->IncRef();
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 resultobj = SWIG_Py_Void();
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3944 PyObject *resultobj = 0;
3945 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3946 void *argp1 = 0 ;
3947 int res1 = 0 ;
3948 PyObject *swig_obj[1] ;
3949
3950 if (!args) SWIG_fail;
3951 swig_obj[0] = args;
3952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3953 if (!SWIG_IsOK(res1)) {
3954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3955 }
3956 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3957 {
3958 PyThreadState* __tstate = wxPyBeginAllowThreads();
3959 (arg1)->DecRef();
3960 wxPyEndAllowThreads(__tstate);
3961 if (PyErr_Occurred()) SWIG_fail;
3962 }
3963 resultobj = SWIG_Py_Void();
3964 return resultobj;
3965 fail:
3966 return NULL;
3967 }
3968
3969
3970 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3971 PyObject *obj;
3972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3973 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3974 return SWIG_Py_Void();
3975 }
3976
3977 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3978 PyObject *obj;
3979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3980 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3981 return SWIG_Py_Void();
3982 }
3983
3984 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3985 PyObject *resultobj = 0;
3986 wxPyGridCellRenderer *result = 0 ;
3987
3988 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3989 {
3990 PyThreadState* __tstate = wxPyBeginAllowThreads();
3991 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3992 wxPyEndAllowThreads(__tstate);
3993 if (PyErr_Occurred()) SWIG_fail;
3994 }
3995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3996 return resultobj;
3997 fail:
3998 return NULL;
3999 }
4000
4001
4002 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4003 PyObject *resultobj = 0;
4004 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4005 PyObject *arg2 = (PyObject *) 0 ;
4006 PyObject *arg3 = (PyObject *) 0 ;
4007 void *argp1 = 0 ;
4008 int res1 = 0 ;
4009 PyObject * obj0 = 0 ;
4010 PyObject * obj1 = 0 ;
4011 PyObject * obj2 = 0 ;
4012 char * kwnames[] = {
4013 (char *) "self",(char *) "self",(char *) "_class", NULL
4014 };
4015
4016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4018 if (!SWIG_IsOK(res1)) {
4019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4020 }
4021 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4022 arg2 = obj1;
4023 arg3 = obj2;
4024 {
4025 PyThreadState* __tstate = wxPyBeginAllowThreads();
4026 (arg1)->_setCallbackInfo(arg2,arg3);
4027 wxPyEndAllowThreads(__tstate);
4028 if (PyErr_Occurred()) SWIG_fail;
4029 }
4030 resultobj = SWIG_Py_Void();
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj = 0;
4039 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4040 wxString *arg2 = 0 ;
4041 void *argp1 = 0 ;
4042 int res1 = 0 ;
4043 bool temp2 = false ;
4044 PyObject * obj0 = 0 ;
4045 PyObject * obj1 = 0 ;
4046 char * kwnames[] = {
4047 (char *) "self",(char *) "params", NULL
4048 };
4049
4050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4052 if (!SWIG_IsOK(res1)) {
4053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4054 }
4055 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4056 {
4057 arg2 = wxString_in_helper(obj1);
4058 if (arg2 == NULL) SWIG_fail;
4059 temp2 = true;
4060 }
4061 {
4062 PyThreadState* __tstate = wxPyBeginAllowThreads();
4063 (arg1)->SetParameters((wxString const &)*arg2);
4064 wxPyEndAllowThreads(__tstate);
4065 if (PyErr_Occurred()) SWIG_fail;
4066 }
4067 resultobj = SWIG_Py_Void();
4068 {
4069 if (temp2)
4070 delete arg2;
4071 }
4072 return resultobj;
4073 fail:
4074 {
4075 if (temp2)
4076 delete arg2;
4077 }
4078 return NULL;
4079 }
4080
4081
4082 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4083 PyObject *obj;
4084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4086 return SWIG_Py_Void();
4087 }
4088
4089 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4090 return SWIG_Python_InitShadowInstance(args);
4091 }
4092
4093 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4094 PyObject *resultobj = 0;
4095 wxGridCellStringRenderer *result = 0 ;
4096
4097 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4098 {
4099 PyThreadState* __tstate = wxPyBeginAllowThreads();
4100 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4101 wxPyEndAllowThreads(__tstate);
4102 if (PyErr_Occurred()) SWIG_fail;
4103 }
4104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4105 return resultobj;
4106 fail:
4107 return NULL;
4108 }
4109
4110
4111 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4112 PyObject *obj;
4113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4114 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4115 return SWIG_Py_Void();
4116 }
4117
4118 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4119 return SWIG_Python_InitShadowInstance(args);
4120 }
4121
4122 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4123 PyObject *resultobj = 0;
4124 wxGridCellNumberRenderer *result = 0 ;
4125
4126 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4127 {
4128 PyThreadState* __tstate = wxPyBeginAllowThreads();
4129 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4130 wxPyEndAllowThreads(__tstate);
4131 if (PyErr_Occurred()) SWIG_fail;
4132 }
4133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4134 return resultobj;
4135 fail:
4136 return NULL;
4137 }
4138
4139
4140 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4141 PyObject *obj;
4142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4143 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4144 return SWIG_Py_Void();
4145 }
4146
4147 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4148 return SWIG_Python_InitShadowInstance(args);
4149 }
4150
4151 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj = 0;
4153 int arg1 = (int) -1 ;
4154 int arg2 = (int) -1 ;
4155 wxGridCellFloatRenderer *result = 0 ;
4156 int val1 ;
4157 int ecode1 = 0 ;
4158 int val2 ;
4159 int ecode2 = 0 ;
4160 PyObject * obj0 = 0 ;
4161 PyObject * obj1 = 0 ;
4162 char * kwnames[] = {
4163 (char *) "width",(char *) "precision", NULL
4164 };
4165
4166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4167 if (obj0) {
4168 ecode1 = SWIG_AsVal_int(obj0, &val1);
4169 if (!SWIG_IsOK(ecode1)) {
4170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4171 }
4172 arg1 = static_cast< int >(val1);
4173 }
4174 if (obj1) {
4175 ecode2 = SWIG_AsVal_int(obj1, &val2);
4176 if (!SWIG_IsOK(ecode2)) {
4177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4178 }
4179 arg2 = static_cast< int >(val2);
4180 }
4181 {
4182 PyThreadState* __tstate = wxPyBeginAllowThreads();
4183 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4195 PyObject *resultobj = 0;
4196 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4197 int result;
4198 void *argp1 = 0 ;
4199 int res1 = 0 ;
4200 PyObject *swig_obj[1] ;
4201
4202 if (!args) SWIG_fail;
4203 swig_obj[0] = args;
4204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4205 if (!SWIG_IsOK(res1)) {
4206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4207 }
4208 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4209 {
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 resultobj = SWIG_From_int(static_cast< int >(result));
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj = 0;
4224 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4225 int arg2 ;
4226 void *argp1 = 0 ;
4227 int res1 = 0 ;
4228 int val2 ;
4229 int ecode2 = 0 ;
4230 PyObject * obj0 = 0 ;
4231 PyObject * obj1 = 0 ;
4232 char * kwnames[] = {
4233 (char *) "self",(char *) "width", NULL
4234 };
4235
4236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4238 if (!SWIG_IsOK(res1)) {
4239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4240 }
4241 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4242 ecode2 = SWIG_AsVal_int(obj1, &val2);
4243 if (!SWIG_IsOK(ecode2)) {
4244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4245 }
4246 arg2 = static_cast< int >(val2);
4247 {
4248 PyThreadState* __tstate = wxPyBeginAllowThreads();
4249 (arg1)->SetWidth(arg2);
4250 wxPyEndAllowThreads(__tstate);
4251 if (PyErr_Occurred()) SWIG_fail;
4252 }
4253 resultobj = SWIG_Py_Void();
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4261 PyObject *resultobj = 0;
4262 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4263 int result;
4264 void *argp1 = 0 ;
4265 int res1 = 0 ;
4266 PyObject *swig_obj[1] ;
4267
4268 if (!args) SWIG_fail;
4269 swig_obj[0] = args;
4270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4271 if (!SWIG_IsOK(res1)) {
4272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4273 }
4274 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4275 {
4276 PyThreadState* __tstate = wxPyBeginAllowThreads();
4277 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4278 wxPyEndAllowThreads(__tstate);
4279 if (PyErr_Occurred()) SWIG_fail;
4280 }
4281 resultobj = SWIG_From_int(static_cast< int >(result));
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4289 PyObject *resultobj = 0;
4290 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4291 int arg2 ;
4292 void *argp1 = 0 ;
4293 int res1 = 0 ;
4294 int val2 ;
4295 int ecode2 = 0 ;
4296 PyObject * obj0 = 0 ;
4297 PyObject * obj1 = 0 ;
4298 char * kwnames[] = {
4299 (char *) "self",(char *) "precision", NULL
4300 };
4301
4302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4304 if (!SWIG_IsOK(res1)) {
4305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4306 }
4307 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4308 ecode2 = SWIG_AsVal_int(obj1, &val2);
4309 if (!SWIG_IsOK(ecode2)) {
4310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4311 }
4312 arg2 = static_cast< int >(val2);
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 (arg1)->SetPrecision(arg2);
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = SWIG_Py_Void();
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4327 PyObject *obj;
4328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4329 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4330 return SWIG_Py_Void();
4331 }
4332
4333 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4334 return SWIG_Python_InitShadowInstance(args);
4335 }
4336
4337 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4338 PyObject *resultobj = 0;
4339 wxGridCellBoolRenderer *result = 0 ;
4340
4341 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4342 {
4343 PyThreadState* __tstate = wxPyBeginAllowThreads();
4344 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4345 wxPyEndAllowThreads(__tstate);
4346 if (PyErr_Occurred()) SWIG_fail;
4347 }
4348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4356 PyObject *obj;
4357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4358 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4359 return SWIG_Py_Void();
4360 }
4361
4362 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4363 return SWIG_Python_InitShadowInstance(args);
4364 }
4365
4366 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj = 0;
4368 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4369 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4370 wxGridCellDateTimeRenderer *result = 0 ;
4371 PyObject * obj0 = 0 ;
4372 PyObject * obj1 = 0 ;
4373 char * kwnames[] = {
4374 (char *) "outformat",(char *) "informat", NULL
4375 };
4376
4377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4378 if (obj0) {
4379 {
4380 wxString* sptr = wxString_in_helper(obj0);
4381 if (sptr == NULL) SWIG_fail;
4382 arg1 = *sptr;
4383 delete sptr;
4384 }
4385 }
4386 if (obj1) {
4387 {
4388 wxString* sptr = wxString_in_helper(obj1);
4389 if (sptr == NULL) SWIG_fail;
4390 arg2 = *sptr;
4391 delete sptr;
4392 }
4393 }
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408 PyObject *obj;
4409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4410 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4411 return SWIG_Py_Void();
4412 }
4413
4414 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415 return SWIG_Python_InitShadowInstance(args);
4416 }
4417
4418 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4419 PyObject *resultobj = 0;
4420 wxString const &arg1_defvalue = wxPyEmptyString ;
4421 wxString *arg1 = (wxString *) &arg1_defvalue ;
4422 wxGridCellEnumRenderer *result = 0 ;
4423 bool temp1 = false ;
4424 PyObject * obj0 = 0 ;
4425 char * kwnames[] = {
4426 (char *) "choices", NULL
4427 };
4428
4429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4430 if (obj0) {
4431 {
4432 arg1 = wxString_in_helper(obj0);
4433 if (arg1 == NULL) SWIG_fail;
4434 temp1 = true;
4435 }
4436 }
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 return SWIG_Python_InitShadowInstance(args);
4467 }
4468
4469 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4470 PyObject *resultobj = 0;
4471 wxGridCellAutoWrapStringRenderer *result = 0 ;
4472
4473 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *obj;
4489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4490 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4491 return SWIG_Py_Void();
4492 }
4493
4494 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4495 return SWIG_Python_InitShadowInstance(args);
4496 }
4497
4498 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499 PyObject *resultobj = 0;
4500 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4501 bool result;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 PyObject *swig_obj[1] ;
4505
4506 if (!args) SWIG_fail;
4507 swig_obj[0] = args;
4508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4509 if (!SWIG_IsOK(res1)) {
4510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4511 }
4512 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4513 {
4514 PyThreadState* __tstate = wxPyBeginAllowThreads();
4515 result = (bool)(arg1)->IsCreated();
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 {
4520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4521 }
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4529 PyObject *resultobj = 0;
4530 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4531 wxControl *result = 0 ;
4532 void *argp1 = 0 ;
4533 int res1 = 0 ;
4534 PyObject *swig_obj[1] ;
4535
4536 if (!args) SWIG_fail;
4537 swig_obj[0] = args;
4538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4539 if (!SWIG_IsOK(res1)) {
4540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4541 }
4542 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4543 {
4544 PyThreadState* __tstate = wxPyBeginAllowThreads();
4545 result = (wxControl *)(arg1)->GetControl();
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = wxPyMake_wxObject(result, 0);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj = 0;
4560 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4561 wxControl *arg2 = (wxControl *) 0 ;
4562 void *argp1 = 0 ;
4563 int res1 = 0 ;
4564 void *argp2 = 0 ;
4565 int res2 = 0 ;
4566 PyObject * obj0 = 0 ;
4567 PyObject * obj1 = 0 ;
4568 char * kwnames[] = {
4569 (char *) "self",(char *) "control", NULL
4570 };
4571
4572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4576 }
4577 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4579 if (!SWIG_IsOK(res2)) {
4580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4581 }
4582 arg2 = reinterpret_cast< wxControl * >(argp2);
4583 {
4584 PyThreadState* __tstate = wxPyBeginAllowThreads();
4585 (arg1)->SetControl(arg2);
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 resultobj = SWIG_Py_Void();
4590 return resultobj;
4591 fail:
4592 return NULL;
4593 }
4594
4595
4596 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4597 PyObject *resultobj = 0;
4598 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4599 wxGridCellAttr *result = 0 ;
4600 void *argp1 = 0 ;
4601 int res1 = 0 ;
4602 PyObject *swig_obj[1] ;
4603
4604 if (!args) SWIG_fail;
4605 swig_obj[0] = args;
4606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4607 if (!SWIG_IsOK(res1)) {
4608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4609 }
4610 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4611 {
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 {
4618 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4619 }
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj = 0;
4628 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4629 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4630 void *argp1 = 0 ;
4631 int res1 = 0 ;
4632 void *argp2 = 0 ;
4633 int res2 = 0 ;
4634 PyObject * obj0 = 0 ;
4635 PyObject * obj1 = 0 ;
4636 char * kwnames[] = {
4637 (char *) "self",(char *) "attr", NULL
4638 };
4639
4640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4644 }
4645 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4647 if (!SWIG_IsOK(res2)) {
4648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4649 }
4650 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 (arg1)->SetCellAttr(arg2);
4654 wxPyEndAllowThreads(__tstate);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 resultobj = SWIG_Py_Void();
4658 return resultobj;
4659 fail:
4660 return NULL;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4665 PyObject *resultobj = 0;
4666 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4667 wxWindow *arg2 = (wxWindow *) 0 ;
4668 int arg3 ;
4669 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4670 void *argp1 = 0 ;
4671 int res1 = 0 ;
4672 void *argp2 = 0 ;
4673 int res2 = 0 ;
4674 int val3 ;
4675 int ecode3 = 0 ;
4676 void *argp4 = 0 ;
4677 int res4 = 0 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 PyObject * obj2 = 0 ;
4681 PyObject * obj3 = 0 ;
4682 char * kwnames[] = {
4683 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4684 };
4685
4686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4688 if (!SWIG_IsOK(res1)) {
4689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4690 }
4691 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4693 if (!SWIG_IsOK(res2)) {
4694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4695 }
4696 arg2 = reinterpret_cast< wxWindow * >(argp2);
4697 ecode3 = SWIG_AsVal_int(obj2, &val3);
4698 if (!SWIG_IsOK(ecode3)) {
4699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4700 }
4701 arg3 = static_cast< int >(val3);
4702 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4703 if (!SWIG_IsOK(res4)) {
4704 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4705 }
4706 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 (arg1)->Create(arg2,arg3,arg4);
4710 wxPyEndAllowThreads(__tstate);
4711 if (PyErr_Occurred()) SWIG_fail;
4712 }
4713 resultobj = SWIG_Py_Void();
4714 return resultobj;
4715 fail:
4716 return NULL;
4717 }
4718
4719
4720 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4721 PyObject *resultobj = 0;
4722 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4723 int arg2 ;
4724 int arg3 ;
4725 wxGrid *arg4 = (wxGrid *) 0 ;
4726 void *argp1 = 0 ;
4727 int res1 = 0 ;
4728 int val2 ;
4729 int ecode2 = 0 ;
4730 int val3 ;
4731 int ecode3 = 0 ;
4732 void *argp4 = 0 ;
4733 int res4 = 0 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 PyObject * obj2 = 0 ;
4737 PyObject * obj3 = 0 ;
4738 char * kwnames[] = {
4739 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4740 };
4741
4742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4746 }
4747 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4748 ecode2 = SWIG_AsVal_int(obj1, &val2);
4749 if (!SWIG_IsOK(ecode2)) {
4750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4751 }
4752 arg2 = static_cast< int >(val2);
4753 ecode3 = SWIG_AsVal_int(obj2, &val3);
4754 if (!SWIG_IsOK(ecode3)) {
4755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4756 }
4757 arg3 = static_cast< int >(val3);
4758 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4759 if (!SWIG_IsOK(res4)) {
4760 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4761 }
4762 arg4 = reinterpret_cast< wxGrid * >(argp4);
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 (arg1)->BeginEdit(arg2,arg3,arg4);
4766 wxPyEndAllowThreads(__tstate);
4767 if (PyErr_Occurred()) SWIG_fail;
4768 }
4769 resultobj = SWIG_Py_Void();
4770 return resultobj;
4771 fail:
4772 return NULL;
4773 }
4774
4775
4776 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj = 0;
4778 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4779 int arg2 ;
4780 int arg3 ;
4781 wxGrid *arg4 = (wxGrid *) 0 ;
4782 bool result;
4783 void *argp1 = 0 ;
4784 int res1 = 0 ;
4785 int val2 ;
4786 int ecode2 = 0 ;
4787 int val3 ;
4788 int ecode3 = 0 ;
4789 void *argp4 = 0 ;
4790 int res4 = 0 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 PyObject * obj2 = 0 ;
4794 PyObject * obj3 = 0 ;
4795 char * kwnames[] = {
4796 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4797 };
4798
4799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4801 if (!SWIG_IsOK(res1)) {
4802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4803 }
4804 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4805 ecode2 = SWIG_AsVal_int(obj1, &val2);
4806 if (!SWIG_IsOK(ecode2)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4808 }
4809 arg2 = static_cast< int >(val2);
4810 ecode3 = SWIG_AsVal_int(obj2, &val3);
4811 if (!SWIG_IsOK(ecode3)) {
4812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4813 }
4814 arg3 = static_cast< int >(val3);
4815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4816 if (!SWIG_IsOK(res4)) {
4817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4818 }
4819 arg4 = reinterpret_cast< wxGrid * >(argp4);
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 {
4827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4828 }
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4836 PyObject *resultobj = 0;
4837 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 PyObject *swig_obj[1] ;
4841
4842 if (!args) SWIG_fail;
4843 swig_obj[0] = args;
4844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4845 if (!SWIG_IsOK(res1)) {
4846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4847 }
4848 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4849 {
4850 PyThreadState* __tstate = wxPyBeginAllowThreads();
4851 (arg1)->Reset();
4852 wxPyEndAllowThreads(__tstate);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_Py_Void();
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4863 PyObject *resultobj = 0;
4864 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4865 wxGridCellEditor *result = 0 ;
4866 void *argp1 = 0 ;
4867 int res1 = 0 ;
4868 PyObject *swig_obj[1] ;
4869
4870 if (!args) SWIG_fail;
4871 swig_obj[0] = args;
4872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4873 if (!SWIG_IsOK(res1)) {
4874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4875 }
4876 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 {
4884 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4885 }
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4895 wxRect *arg2 = 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 wxRect temp2 ;
4899 PyObject * obj0 = 0 ;
4900 PyObject * obj1 = 0 ;
4901 char * kwnames[] = {
4902 (char *) "self",(char *) "rect", NULL
4903 };
4904
4905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4907 if (!SWIG_IsOK(res1)) {
4908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4909 }
4910 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4911 {
4912 arg2 = &temp2;
4913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 (arg1)->SetSize((wxRect const &)*arg2);
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 resultobj = SWIG_Py_Void();
4922 return resultobj;
4923 fail:
4924 return NULL;
4925 }
4926
4927
4928 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4929 PyObject *resultobj = 0;
4930 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4931 bool arg2 ;
4932 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4933 void *argp1 = 0 ;
4934 int res1 = 0 ;
4935 bool val2 ;
4936 int ecode2 = 0 ;
4937 void *argp3 = 0 ;
4938 int res3 = 0 ;
4939 PyObject * obj0 = 0 ;
4940 PyObject * obj1 = 0 ;
4941 PyObject * obj2 = 0 ;
4942 char * kwnames[] = {
4943 (char *) "self",(char *) "show",(char *) "attr", NULL
4944 };
4945
4946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4948 if (!SWIG_IsOK(res1)) {
4949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4950 }
4951 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4953 if (!SWIG_IsOK(ecode2)) {
4954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4955 }
4956 arg2 = static_cast< bool >(val2);
4957 if (obj2) {
4958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4959 if (!SWIG_IsOK(res3)) {
4960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4961 }
4962 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4963 }
4964 {
4965 PyThreadState* __tstate = wxPyBeginAllowThreads();
4966 (arg1)->Show(arg2,arg3);
4967 wxPyEndAllowThreads(__tstate);
4968 if (PyErr_Occurred()) SWIG_fail;
4969 }
4970 resultobj = SWIG_Py_Void();
4971 return resultobj;
4972 fail:
4973 return NULL;
4974 }
4975
4976
4977 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4978 PyObject *resultobj = 0;
4979 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4980 wxRect *arg2 = 0 ;
4981 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4982 void *argp1 = 0 ;
4983 int res1 = 0 ;
4984 wxRect temp2 ;
4985 void *argp3 = 0 ;
4986 int res3 = 0 ;
4987 PyObject * obj0 = 0 ;
4988 PyObject * obj1 = 0 ;
4989 PyObject * obj2 = 0 ;
4990 char * kwnames[] = {
4991 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4992 };
4993
4994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4996 if (!SWIG_IsOK(res1)) {
4997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4998 }
4999 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5000 {
5001 arg2 = &temp2;
5002 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5003 }
5004 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5005 if (!SWIG_IsOK(res3)) {
5006 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5007 }
5008 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 resultobj = SWIG_Py_Void();
5016 return resultobj;
5017 fail:
5018 return NULL;
5019 }
5020
5021
5022 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj = 0;
5024 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5025 wxKeyEvent *arg2 = 0 ;
5026 bool result;
5027 void *argp1 = 0 ;
5028 int res1 = 0 ;
5029 void *argp2 = 0 ;
5030 int res2 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 char * kwnames[] = {
5034 (char *) "self",(char *) "event", NULL
5035 };
5036
5037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5041 }
5042 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5044 if (!SWIG_IsOK(res2)) {
5045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5046 }
5047 if (!argp2) {
5048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5049 }
5050 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5054 wxPyEndAllowThreads(__tstate);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 {
5058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5059 }
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj = 0;
5068 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5069 wxKeyEvent *arg2 = 0 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 void *argp2 = 0 ;
5073 int res2 = 0 ;
5074 PyObject * obj0 = 0 ;
5075 PyObject * obj1 = 0 ;
5076 char * kwnames[] = {
5077 (char *) "self",(char *) "event", NULL
5078 };
5079
5080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5082 if (!SWIG_IsOK(res1)) {
5083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5084 }
5085 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5086 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5087 if (!SWIG_IsOK(res2)) {
5088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5089 }
5090 if (!argp2) {
5091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5092 }
5093 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 (arg1)->StartingKey(*arg2);
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 resultobj = SWIG_Py_Void();
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *resultobj = 0;
5109 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 PyObject *swig_obj[1] ;
5113
5114 if (!args) SWIG_fail;
5115 swig_obj[0] = args;
5116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5117 if (!SWIG_IsOK(res1)) {
5118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5119 }
5120 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 (arg1)->StartingClick();
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 resultobj = SWIG_Py_Void();
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj = 0;
5136 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5137 wxKeyEvent *arg2 = 0 ;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 void *argp2 = 0 ;
5141 int res2 = 0 ;
5142 PyObject * obj0 = 0 ;
5143 PyObject * obj1 = 0 ;
5144 char * kwnames[] = {
5145 (char *) "self",(char *) "event", NULL
5146 };
5147
5148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5150 if (!SWIG_IsOK(res1)) {
5151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5152 }
5153 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5155 if (!SWIG_IsOK(res2)) {
5156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5157 }
5158 if (!argp2) {
5159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5160 }
5161 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5162 {
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 (arg1)->HandleReturn(*arg2);
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 resultobj = SWIG_Py_Void();
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *resultobj = 0;
5177 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5178 void *argp1 = 0 ;
5179 int res1 = 0 ;
5180 PyObject *swig_obj[1] ;
5181
5182 if (!args) SWIG_fail;
5183 swig_obj[0] = args;
5184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5185 if (!SWIG_IsOK(res1)) {
5186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5187 }
5188 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5189 {
5190 PyThreadState* __tstate = wxPyBeginAllowThreads();
5191 (arg1)->Destroy();
5192 wxPyEndAllowThreads(__tstate);
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 resultobj = SWIG_Py_Void();
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
5202 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *obj;
5204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5205 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5206 return SWIG_Py_Void();
5207 }
5208
5209 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5210 PyObject *resultobj = 0;
5211 wxPyGridCellEditor *result = 0 ;
5212
5213 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5217 wxPyEndAllowThreads(__tstate);
5218 if (PyErr_Occurred()) SWIG_fail;
5219 }
5220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5221 return resultobj;
5222 fail:
5223 return NULL;
5224 }
5225
5226
5227 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5228 PyObject *resultobj = 0;
5229 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5230 PyObject *arg2 = (PyObject *) 0 ;
5231 PyObject *arg3 = (PyObject *) 0 ;
5232 void *argp1 = 0 ;
5233 int res1 = 0 ;
5234 PyObject * obj0 = 0 ;
5235 PyObject * obj1 = 0 ;
5236 PyObject * obj2 = 0 ;
5237 char * kwnames[] = {
5238 (char *) "self",(char *) "self",(char *) "_class", NULL
5239 };
5240
5241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5243 if (!SWIG_IsOK(res1)) {
5244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5245 }
5246 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5247 arg2 = obj1;
5248 arg3 = obj2;
5249 {
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 (arg1)->_setCallbackInfo(arg2,arg3);
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 resultobj = SWIG_Py_Void();
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5265 wxString *arg2 = 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 bool temp2 = false ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "params", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5279 }
5280 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5281 {
5282 arg2 = wxString_in_helper(obj1);
5283 if (arg2 == NULL) SWIG_fail;
5284 temp2 = true;
5285 }
5286 {
5287 PyThreadState* __tstate = wxPyBeginAllowThreads();
5288 (arg1)->SetParameters((wxString const &)*arg2);
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 resultobj = SWIG_Py_Void();
5293 {
5294 if (temp2)
5295 delete arg2;
5296 }
5297 return resultobj;
5298 fail:
5299 {
5300 if (temp2)
5301 delete arg2;
5302 }
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5308 PyObject *obj;
5309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5310 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5311 return SWIG_Py_Void();
5312 }
5313
5314 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5315 return SWIG_Python_InitShadowInstance(args);
5316 }
5317
5318 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5319 PyObject *resultobj = 0;
5320 wxGridCellTextEditor *result = 0 ;
5321
5322 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5323 {
5324 PyThreadState* __tstate = wxPyBeginAllowThreads();
5325 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337 PyObject *resultobj = 0;
5338 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5339 wxString result;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 PyObject *swig_obj[1] ;
5343
5344 if (!args) SWIG_fail;
5345 swig_obj[0] = args;
5346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5347 if (!SWIG_IsOK(res1)) {
5348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5349 }
5350 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5351 {
5352 PyThreadState* __tstate = wxPyBeginAllowThreads();
5353 result = (arg1)->GetValue();
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 {
5358 #if wxUSE_UNICODE
5359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5360 #else
5361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5362 #endif
5363 }
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5371 PyObject *obj;
5372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5373 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5374 return SWIG_Py_Void();
5375 }
5376
5377 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5378 return SWIG_Python_InitShadowInstance(args);
5379 }
5380
5381 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5382 PyObject *resultobj = 0;
5383 int arg1 = (int) -1 ;
5384 int arg2 = (int) -1 ;
5385 wxGridCellNumberEditor *result = 0 ;
5386 int val1 ;
5387 int ecode1 = 0 ;
5388 int val2 ;
5389 int ecode2 = 0 ;
5390 PyObject * obj0 = 0 ;
5391 PyObject * obj1 = 0 ;
5392 char * kwnames[] = {
5393 (char *) "min",(char *) "max", NULL
5394 };
5395
5396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5397 if (obj0) {
5398 ecode1 = SWIG_AsVal_int(obj0, &val1);
5399 if (!SWIG_IsOK(ecode1)) {
5400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5401 }
5402 arg1 = static_cast< int >(val1);
5403 }
5404 if (obj1) {
5405 ecode2 = SWIG_AsVal_int(obj1, &val2);
5406 if (!SWIG_IsOK(ecode2)) {
5407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5408 }
5409 arg2 = static_cast< int >(val2);
5410 }
5411 {
5412 PyThreadState* __tstate = wxPyBeginAllowThreads();
5413 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5414 wxPyEndAllowThreads(__tstate);
5415 if (PyErr_Occurred()) SWIG_fail;
5416 }
5417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *obj;
5426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5427 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5428 return SWIG_Py_Void();
5429 }
5430
5431 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 return SWIG_Python_InitShadowInstance(args);
5433 }
5434
5435 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5436 PyObject *resultobj = 0;
5437 int arg1 = (int) -1 ;
5438 int arg2 = (int) -1 ;
5439 wxGridCellFloatEditor *result = 0 ;
5440 int val1 ;
5441 int ecode1 = 0 ;
5442 int val2 ;
5443 int ecode2 = 0 ;
5444 PyObject * obj0 = 0 ;
5445 PyObject * obj1 = 0 ;
5446 char * kwnames[] = {
5447 (char *) "width",(char *) "precision", NULL
5448 };
5449
5450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5451 if (obj0) {
5452 ecode1 = SWIG_AsVal_int(obj0, &val1);
5453 if (!SWIG_IsOK(ecode1)) {
5454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5455 }
5456 arg1 = static_cast< int >(val1);
5457 }
5458 if (obj1) {
5459 ecode2 = SWIG_AsVal_int(obj1, &val2);
5460 if (!SWIG_IsOK(ecode2)) {
5461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5462 }
5463 arg2 = static_cast< int >(val2);
5464 }
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *obj;
5480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5481 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5482 return SWIG_Py_Void();
5483 }
5484
5485 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5486 return SWIG_Python_InitShadowInstance(args);
5487 }
5488
5489 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5490 PyObject *resultobj = 0;
5491 wxGridCellBoolEditor *result = 0 ;
5492
5493 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5494 {
5495 PyThreadState* __tstate = wxPyBeginAllowThreads();
5496 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5508 PyObject *resultobj = 0;
5509 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5510 wxString result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject *swig_obj[1] ;
5514
5515 if (!args) SWIG_fail;
5516 swig_obj[0] = args;
5517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5518 if (!SWIG_IsOK(res1)) {
5519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5520 }
5521 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5522 {
5523 PyThreadState* __tstate = wxPyBeginAllowThreads();
5524 result = (arg1)->GetValue();
5525 wxPyEndAllowThreads(__tstate);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 {
5529 #if wxUSE_UNICODE
5530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5531 #else
5532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5533 #endif
5534 }
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5542 PyObject *obj;
5543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5544 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5545 return SWIG_Py_Void();
5546 }
5547
5548 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5549 return SWIG_Python_InitShadowInstance(args);
5550 }
5551
5552 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5553 PyObject *resultobj = 0;
5554 int arg1 = (int) 0 ;
5555 wxString *arg2 = (wxString *) NULL ;
5556 bool arg3 = (bool) false ;
5557 wxGridCellChoiceEditor *result = 0 ;
5558 bool val3 ;
5559 int ecode3 = 0 ;
5560 PyObject * obj0 = 0 ;
5561 PyObject * obj1 = 0 ;
5562 char * kwnames[] = {
5563 (char *) "choices",(char *) "allowOthers", NULL
5564 };
5565
5566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5567 if (obj0) {
5568 {
5569 arg1 = PyList_Size(obj0);
5570 arg2 = wxString_LIST_helper(obj0);
5571 if (arg2 == NULL) SWIG_fail;
5572 }
5573 }
5574 if (obj1) {
5575 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5576 if (!SWIG_IsOK(ecode3)) {
5577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5578 }
5579 arg3 = static_cast< bool >(val3);
5580 }
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5584 wxPyEndAllowThreads(__tstate);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5588 {
5589 if (arg2) delete [] arg2;
5590 }
5591 return resultobj;
5592 fail:
5593 {
5594 if (arg2) delete [] arg2;
5595 }
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5603 wxString result;
5604 void *argp1 = 0 ;
5605 int res1 = 0 ;
5606 PyObject *swig_obj[1] ;
5607
5608 if (!args) SWIG_fail;
5609 swig_obj[0] = args;
5610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5613 }
5614 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5615 {
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 result = (arg1)->GetValue();
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 {
5622 #if wxUSE_UNICODE
5623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5624 #else
5625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5626 #endif
5627 }
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *obj;
5636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5637 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5638 return SWIG_Py_Void();
5639 }
5640
5641 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 return SWIG_Python_InitShadowInstance(args);
5643 }
5644
5645 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj = 0;
5647 wxString const &arg1_defvalue = wxPyEmptyString ;
5648 wxString *arg1 = (wxString *) &arg1_defvalue ;
5649 wxGridCellEnumEditor *result = 0 ;
5650 bool temp1 = false ;
5651 PyObject * obj0 = 0 ;
5652 char * kwnames[] = {
5653 (char *) "choices", NULL
5654 };
5655
5656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5657 if (obj0) {
5658 {
5659 arg1 = wxString_in_helper(obj0);
5660 if (arg1 == NULL) SWIG_fail;
5661 temp1 = true;
5662 }
5663 }
5664 {
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5667 wxPyEndAllowThreads(__tstate);
5668 if (PyErr_Occurred()) SWIG_fail;
5669 }
5670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5671 {
5672 if (temp1)
5673 delete arg1;
5674 }
5675 return resultobj;
5676 fail:
5677 {
5678 if (temp1)
5679 delete arg1;
5680 }
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5686 PyObject *obj;
5687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5688 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5689 return SWIG_Py_Void();
5690 }
5691
5692 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5693 return SWIG_Python_InitShadowInstance(args);
5694 }
5695
5696 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697 PyObject *resultobj = 0;
5698 wxGridCellAutoWrapStringEditor *result = 0 ;
5699
5700 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5701 {
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 PyObject *obj;
5716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5717 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5718 return SWIG_Py_Void();
5719 }
5720
5721 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5722 return SWIG_Python_InitShadowInstance(args);
5723 }
5724
5725 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5726 PyObject *resultobj = 0;
5727 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5728 PyObject *arg2 = (PyObject *) 0 ;
5729 void *argp1 = 0 ;
5730 int res1 = 0 ;
5731 PyObject * obj0 = 0 ;
5732 PyObject * obj1 = 0 ;
5733 char * kwnames[] = {
5734 (char *) "self",(char *) "_self", NULL
5735 };
5736
5737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5739 if (!SWIG_IsOK(res1)) {
5740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5741 }
5742 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5743 arg2 = obj1;
5744 {
5745 PyThreadState* __tstate = wxPyBeginAllowThreads();
5746 wxGridCellAttr__setOORInfo(arg1,arg2);
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 resultobj = SWIG_Py_Void();
5751 return resultobj;
5752 fail:
5753 return NULL;
5754 }
5755
5756
5757 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5758 PyObject *resultobj = 0;
5759 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5760 wxGridCellAttr *result = 0 ;
5761 void *argp1 = 0 ;
5762 int res1 = 0 ;
5763 PyObject * obj0 = 0 ;
5764 char * kwnames[] = {
5765 (char *) "attrDefault", NULL
5766 };
5767
5768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5769 if (obj0) {
5770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5771 if (!SWIG_IsOK(res1)) {
5772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5773 }
5774 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 {
5783 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5784 }
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5792 PyObject *resultobj = 0;
5793 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5794 void *argp1 = 0 ;
5795 int res1 = 0 ;
5796 PyObject *swig_obj[1] ;
5797
5798 if (!args) SWIG_fail;
5799 swig_obj[0] = args;
5800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5801 if (!SWIG_IsOK(res1)) {
5802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5803 }
5804 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 delete_wxGridCellAttr(arg1);
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 resultobj = SWIG_Py_Void();
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5820 PyObject *resultobj = 0;
5821 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5822 wxGridCellAttr *result = 0 ;
5823 void *argp1 = 0 ;
5824 int res1 = 0 ;
5825 PyObject *swig_obj[1] ;
5826
5827 if (!args) SWIG_fail;
5828 swig_obj[0] = args;
5829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5830 if (!SWIG_IsOK(res1)) {
5831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5832 }
5833 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5834 {
5835 PyThreadState* __tstate = wxPyBeginAllowThreads();
5836 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5837 wxPyEndAllowThreads(__tstate);
5838 if (PyErr_Occurred()) SWIG_fail;
5839 }
5840 {
5841 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5842 }
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5852 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5853 void *argp1 = 0 ;
5854 int res1 = 0 ;
5855 void *argp2 = 0 ;
5856 int res2 = 0 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "self",(char *) "mergefrom", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5865 if (!SWIG_IsOK(res1)) {
5866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5867 }
5868 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5870 if (!SWIG_IsOK(res2)) {
5871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5872 }
5873 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 (arg1)->MergeWith(arg2);
5877 wxPyEndAllowThreads(__tstate);
5878 if (PyErr_Occurred()) SWIG_fail;
5879 }
5880 resultobj = SWIG_Py_Void();
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5888 PyObject *resultobj = 0;
5889 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 PyObject *swig_obj[1] ;
5893
5894 if (!args) SWIG_fail;
5895 swig_obj[0] = args;
5896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5899 }
5900 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5901 {
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 (arg1)->IncRef();
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 resultobj = SWIG_Py_Void();
5908 return resultobj;
5909 fail:
5910 return NULL;
5911 }
5912
5913
5914 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5915 PyObject *resultobj = 0;
5916 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5917 void *argp1 = 0 ;
5918 int res1 = 0 ;
5919 PyObject *swig_obj[1] ;
5920
5921 if (!args) SWIG_fail;
5922 swig_obj[0] = args;
5923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5924 if (!SWIG_IsOK(res1)) {
5925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5926 }
5927 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5928 {
5929 PyThreadState* __tstate = wxPyBeginAllowThreads();
5930 (arg1)->DecRef();
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 resultobj = SWIG_Py_Void();
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5944 wxColour *arg2 = 0 ;
5945 void *argp1 = 0 ;
5946 int res1 = 0 ;
5947 wxColour temp2 ;
5948 PyObject * obj0 = 0 ;
5949 PyObject * obj1 = 0 ;
5950 char * kwnames[] = {
5951 (char *) "self",(char *) "colText", NULL
5952 };
5953
5954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5958 }
5959 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5960 {
5961 arg2 = &temp2;
5962 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5963 }
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 (arg1)->SetTextColour((wxColour const &)*arg2);
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 resultobj = SWIG_Py_Void();
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5978 PyObject *resultobj = 0;
5979 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5980 wxColour *arg2 = 0 ;
5981 void *argp1 = 0 ;
5982 int res1 = 0 ;
5983 wxColour temp2 ;
5984 PyObject * obj0 = 0 ;
5985 PyObject * obj1 = 0 ;
5986 char * kwnames[] = {
5987 (char *) "self",(char *) "colBack", NULL
5988 };
5989
5990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5992 if (!SWIG_IsOK(res1)) {
5993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5994 }
5995 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5996 {
5997 arg2 = &temp2;
5998 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5999 }
6000 {
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_Py_Void();
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj = 0;
6015 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6016 wxFont *arg2 = 0 ;
6017 void *argp1 = 0 ;
6018 int res1 = 0 ;
6019 void *argp2 = 0 ;
6020 int res2 = 0 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 char * kwnames[] = {
6024 (char *) "self",(char *) "font", NULL
6025 };
6026
6027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6029 if (!SWIG_IsOK(res1)) {
6030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6031 }
6032 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6033 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6034 if (!SWIG_IsOK(res2)) {
6035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6036 }
6037 if (!argp2) {
6038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6039 }
6040 arg2 = reinterpret_cast< wxFont * >(argp2);
6041 {
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 (arg1)->SetFont((wxFont const &)*arg2);
6044 wxPyEndAllowThreads(__tstate);
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 resultobj = SWIG_Py_Void();
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6057 int arg2 ;
6058 int arg3 ;
6059 void *argp1 = 0 ;
6060 int res1 = 0 ;
6061 int val2 ;
6062 int ecode2 = 0 ;
6063 int val3 ;
6064 int ecode3 = 0 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 PyObject * obj2 = 0 ;
6068 char * kwnames[] = {
6069 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6070 };
6071
6072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6074 if (!SWIG_IsOK(res1)) {
6075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6076 }
6077 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6078 ecode2 = SWIG_AsVal_int(obj1, &val2);
6079 if (!SWIG_IsOK(ecode2)) {
6080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6081 }
6082 arg2 = static_cast< int >(val2);
6083 ecode3 = SWIG_AsVal_int(obj2, &val3);
6084 if (!SWIG_IsOK(ecode3)) {
6085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6086 }
6087 arg3 = static_cast< int >(val3);
6088 {
6089 PyThreadState* __tstate = wxPyBeginAllowThreads();
6090 (arg1)->SetAlignment(arg2,arg3);
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 resultobj = SWIG_Py_Void();
6095 return resultobj;
6096 fail:
6097 return NULL;
6098 }
6099
6100
6101 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6102 PyObject *resultobj = 0;
6103 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6104 int arg2 ;
6105 int arg3 ;
6106 void *argp1 = 0 ;
6107 int res1 = 0 ;
6108 int val2 ;
6109 int ecode2 = 0 ;
6110 int val3 ;
6111 int ecode3 = 0 ;
6112 PyObject * obj0 = 0 ;
6113 PyObject * obj1 = 0 ;
6114 PyObject * obj2 = 0 ;
6115 char * kwnames[] = {
6116 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6117 };
6118
6119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6121 if (!SWIG_IsOK(res1)) {
6122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6123 }
6124 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6125 ecode2 = SWIG_AsVal_int(obj1, &val2);
6126 if (!SWIG_IsOK(ecode2)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6128 }
6129 arg2 = static_cast< int >(val2);
6130 ecode3 = SWIG_AsVal_int(obj2, &val3);
6131 if (!SWIG_IsOK(ecode3)) {
6132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6133 }
6134 arg3 = static_cast< int >(val3);
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 (arg1)->SetSize(arg2,arg3);
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 resultobj = SWIG_Py_Void();
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj = 0;
6150 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6151 bool arg2 = (bool) true ;
6152 void *argp1 = 0 ;
6153 int res1 = 0 ;
6154 bool val2 ;
6155 int ecode2 = 0 ;
6156 PyObject * obj0 = 0 ;
6157 PyObject * obj1 = 0 ;
6158 char * kwnames[] = {
6159 (char *) "self",(char *) "allow", NULL
6160 };
6161
6162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6164 if (!SWIG_IsOK(res1)) {
6165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6166 }
6167 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6168 if (obj1) {
6169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6170 if (!SWIG_IsOK(ecode2)) {
6171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6172 }
6173 arg2 = static_cast< bool >(val2);
6174 }
6175 {
6176 PyThreadState* __tstate = wxPyBeginAllowThreads();
6177 (arg1)->SetOverflow(arg2);
6178 wxPyEndAllowThreads(__tstate);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 resultobj = SWIG_Py_Void();
6182 return resultobj;
6183 fail:
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6189 PyObject *resultobj = 0;
6190 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6191 bool arg2 = (bool) true ;
6192 void *argp1 = 0 ;
6193 int res1 = 0 ;
6194 bool val2 ;
6195 int ecode2 = 0 ;
6196 PyObject * obj0 = 0 ;
6197 PyObject * obj1 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "self",(char *) "isReadOnly", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6204 if (!SWIG_IsOK(res1)) {
6205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6206 }
6207 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6208 if (obj1) {
6209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6210 if (!SWIG_IsOK(ecode2)) {
6211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6212 }
6213 arg2 = static_cast< bool >(val2);
6214 }
6215 {
6216 PyThreadState* __tstate = wxPyBeginAllowThreads();
6217 (arg1)->SetReadOnly(arg2);
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 resultobj = SWIG_Py_Void();
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj = 0;
6230 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6231 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 void *argp2 = 0 ;
6235 int res2 = 0 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 char * kwnames[] = {
6239 (char *) "self",(char *) "renderer", NULL
6240 };
6241
6242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6246 }
6247 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6249 if (!SWIG_IsOK(res2)) {
6250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6251 }
6252 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6253 {
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 (arg1)->SetRenderer(arg2);
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_Py_Void();
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj = 0;
6268 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6269 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6270 void *argp1 = 0 ;
6271 int res1 = 0 ;
6272 void *argp2 = 0 ;
6273 int res2 = 0 ;
6274 PyObject * obj0 = 0 ;
6275 PyObject * obj1 = 0 ;
6276 char * kwnames[] = {
6277 (char *) "self",(char *) "editor", NULL
6278 };
6279
6280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6282 if (!SWIG_IsOK(res1)) {
6283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6284 }
6285 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6287 if (!SWIG_IsOK(res2)) {
6288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6289 }
6290 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6291 {
6292 PyThreadState* __tstate = wxPyBeginAllowThreads();
6293 (arg1)->SetEditor(arg2);
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 resultobj = SWIG_Py_Void();
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6307 wxGridCellAttr::wxAttrKind arg2 ;
6308 void *argp1 = 0 ;
6309 int res1 = 0 ;
6310 int val2 ;
6311 int ecode2 = 0 ;
6312 PyObject * obj0 = 0 ;
6313 PyObject * obj1 = 0 ;
6314 char * kwnames[] = {
6315 (char *) "self",(char *) "kind", NULL
6316 };
6317
6318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6322 }
6323 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6324 ecode2 = SWIG_AsVal_int(obj1, &val2);
6325 if (!SWIG_IsOK(ecode2)) {
6326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6327 }
6328 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 (arg1)->SetKind(arg2);
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_Py_Void();
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6343 PyObject *resultobj = 0;
6344 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6345 bool result;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 PyObject *swig_obj[1] ;
6349
6350 if (!args) SWIG_fail;
6351 swig_obj[0] = args;
6352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6355 }
6356 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 {
6364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6365 }
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373 PyObject *resultobj = 0;
6374 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6375 bool result;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 PyObject *swig_obj[1] ;
6379
6380 if (!args) SWIG_fail;
6381 swig_obj[0] = args;
6382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6385 }
6386 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6390 wxPyEndAllowThreads(__tstate);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 {
6394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6395 }
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6403 PyObject *resultobj = 0;
6404 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6405 bool result;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 PyObject *swig_obj[1] ;
6409
6410 if (!args) SWIG_fail;
6411 swig_obj[0] = args;
6412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6413 if (!SWIG_IsOK(res1)) {
6414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6415 }
6416 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6417 {
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6420 wxPyEndAllowThreads(__tstate);
6421 if (PyErr_Occurred()) SWIG_fail;
6422 }
6423 {
6424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6425 }
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6433 PyObject *resultobj = 0;
6434 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6435 bool result;
6436 void *argp1 = 0 ;
6437 int res1 = 0 ;
6438 PyObject *swig_obj[1] ;
6439
6440 if (!args) SWIG_fail;
6441 swig_obj[0] = args;
6442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6443 if (!SWIG_IsOK(res1)) {
6444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6445 }
6446 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6450 wxPyEndAllowThreads(__tstate);
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 {
6454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6455 }
6456 return resultobj;
6457 fail:
6458 return NULL;
6459 }
6460
6461
6462 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6463 PyObject *resultobj = 0;
6464 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6465 bool result;
6466 void *argp1 = 0 ;
6467 int res1 = 0 ;
6468 PyObject *swig_obj[1] ;
6469
6470 if (!args) SWIG_fail;
6471 swig_obj[0] = args;
6472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6473 if (!SWIG_IsOK(res1)) {
6474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6475 }
6476 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 {
6484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6485 }
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6493 PyObject *resultobj = 0;
6494 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6495 bool result;
6496 void *argp1 = 0 ;
6497 int res1 = 0 ;
6498 PyObject *swig_obj[1] ;
6499
6500 if (!args) SWIG_fail;
6501 swig_obj[0] = args;
6502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6503 if (!SWIG_IsOK(res1)) {
6504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6505 }
6506 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6507 {
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 {
6514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6515 }
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 PyObject *resultobj = 0;
6524 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6525 bool result;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 PyObject *swig_obj[1] ;
6529
6530 if (!args) SWIG_fail;
6531 swig_obj[0] = args;
6532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6533 if (!SWIG_IsOK(res1)) {
6534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6535 }
6536 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 {
6544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6545 }
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553 PyObject *resultobj = 0;
6554 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6555 bool result;
6556 void *argp1 = 0 ;
6557 int res1 = 0 ;
6558 PyObject *swig_obj[1] ;
6559
6560 if (!args) SWIG_fail;
6561 swig_obj[0] = args;
6562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6563 if (!SWIG_IsOK(res1)) {
6564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6565 }
6566 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6567 {
6568 PyThreadState* __tstate = wxPyBeginAllowThreads();
6569 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6570 wxPyEndAllowThreads(__tstate);
6571 if (PyErr_Occurred()) SWIG_fail;
6572 }
6573 {
6574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6575 }
6576 return resultobj;
6577 fail:
6578 return NULL;
6579 }
6580
6581
6582 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6583 PyObject *resultobj = 0;
6584 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6585 wxColour result;
6586 void *argp1 = 0 ;
6587 int res1 = 0 ;
6588 PyObject *swig_obj[1] ;
6589
6590 if (!args) SWIG_fail;
6591 swig_obj[0] = args;
6592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6593 if (!SWIG_IsOK(res1)) {
6594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6595 }
6596 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6597 {
6598 PyThreadState* __tstate = wxPyBeginAllowThreads();
6599 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6600 wxPyEndAllowThreads(__tstate);
6601 if (PyErr_Occurred()) SWIG_fail;
6602 }
6603 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6604 return resultobj;
6605 fail:
6606 return NULL;
6607 }
6608
6609
6610 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6611 PyObject *resultobj = 0;
6612 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6613 wxColour result;
6614 void *argp1 = 0 ;
6615 int res1 = 0 ;
6616 PyObject *swig_obj[1] ;
6617
6618 if (!args) SWIG_fail;
6619 swig_obj[0] = args;
6620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6621 if (!SWIG_IsOK(res1)) {
6622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6623 }
6624 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6641 wxFont result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = ((wxGridCellAttr const *)arg1)->GetFont();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6667 PyObject *resultobj = 0;
6668 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6669 int *arg2 = (int *) 0 ;
6670 int *arg3 = (int *) 0 ;
6671 void *argp1 = 0 ;
6672 int res1 = 0 ;
6673 int temp2 ;
6674 int res2 = SWIG_TMPOBJ ;
6675 int temp3 ;
6676 int res3 = SWIG_TMPOBJ ;
6677 PyObject *swig_obj[1] ;
6678
6679 arg2 = &temp2;
6680 arg3 = &temp3;
6681 if (!args) SWIG_fail;
6682 swig_obj[0] = args;
6683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6684 if (!SWIG_IsOK(res1)) {
6685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6686 }
6687 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 resultobj = SWIG_Py_Void();
6695 if (SWIG_IsTmpObj(res2)) {
6696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6697 } else {
6698 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6700 }
6701 if (SWIG_IsTmpObj(res3)) {
6702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6703 } else {
6704 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6706 }
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6714 PyObject *resultobj = 0;
6715 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6716 int *arg2 = (int *) 0 ;
6717 int *arg3 = (int *) 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 int temp2 ;
6721 int res2 = SWIG_TMPOBJ ;
6722 int temp3 ;
6723 int res3 = SWIG_TMPOBJ ;
6724 PyObject *swig_obj[1] ;
6725
6726 arg2 = &temp2;
6727 arg3 = &temp3;
6728 if (!args) SWIG_fail;
6729 swig_obj[0] = args;
6730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6731 if (!SWIG_IsOK(res1)) {
6732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6733 }
6734 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 if (SWIG_IsTmpObj(res2)) {
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6744 } else {
6745 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6747 }
6748 if (SWIG_IsTmpObj(res3)) {
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6750 } else {
6751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6753 }
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6763 bool result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 {
6782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6783 }
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj = 0;
6792 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6793 wxGrid *arg2 = (wxGrid *) 0 ;
6794 int arg3 ;
6795 int arg4 ;
6796 wxGridCellRenderer *result = 0 ;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 void *argp2 = 0 ;
6800 int res2 = 0 ;
6801 int val3 ;
6802 int ecode3 = 0 ;
6803 int val4 ;
6804 int ecode4 = 0 ;
6805 PyObject * obj0 = 0 ;
6806 PyObject * obj1 = 0 ;
6807 PyObject * obj2 = 0 ;
6808 PyObject * obj3 = 0 ;
6809 char * kwnames[] = {
6810 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6811 };
6812
6813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6815 if (!SWIG_IsOK(res1)) {
6816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6817 }
6818 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6820 if (!SWIG_IsOK(res2)) {
6821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6822 }
6823 arg2 = reinterpret_cast< wxGrid * >(argp2);
6824 ecode3 = SWIG_AsVal_int(obj2, &val3);
6825 if (!SWIG_IsOK(ecode3)) {
6826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6827 }
6828 arg3 = static_cast< int >(val3);
6829 ecode4 = SWIG_AsVal_int(obj3, &val4);
6830 if (!SWIG_IsOK(ecode4)) {
6831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6832 }
6833 arg4 = static_cast< int >(val4);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6842 }
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj = 0;
6851 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6852 wxGrid *arg2 = (wxGrid *) 0 ;
6853 int arg3 ;
6854 int arg4 ;
6855 wxGridCellEditor *result = 0 ;
6856 void *argp1 = 0 ;
6857 int res1 = 0 ;
6858 void *argp2 = 0 ;
6859 int res2 = 0 ;
6860 int val3 ;
6861 int ecode3 = 0 ;
6862 int val4 ;
6863 int ecode4 = 0 ;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 PyObject * obj2 = 0 ;
6867 PyObject * obj3 = 0 ;
6868 char * kwnames[] = {
6869 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6870 };
6871
6872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6874 if (!SWIG_IsOK(res1)) {
6875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6876 }
6877 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6879 if (!SWIG_IsOK(res2)) {
6880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6881 }
6882 arg2 = reinterpret_cast< wxGrid * >(argp2);
6883 ecode3 = SWIG_AsVal_int(obj2, &val3);
6884 if (!SWIG_IsOK(ecode3)) {
6885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6886 }
6887 arg3 = static_cast< int >(val3);
6888 ecode4 = SWIG_AsVal_int(obj3, &val4);
6889 if (!SWIG_IsOK(ecode4)) {
6890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6891 }
6892 arg4 = static_cast< int >(val4);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 {
6900 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6901 }
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909 PyObject *resultobj = 0;
6910 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6911 bool result;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 PyObject *swig_obj[1] ;
6915
6916 if (!args) SWIG_fail;
6917 swig_obj[0] = args;
6918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6919 if (!SWIG_IsOK(res1)) {
6920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6921 }
6922 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 {
6930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6931 }
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6939 PyObject *resultobj = 0;
6940 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6941 wxGridCellAttr::wxAttrKind result;
6942 void *argp1 = 0 ;
6943 int res1 = 0 ;
6944 PyObject *swig_obj[1] ;
6945
6946 if (!args) SWIG_fail;
6947 swig_obj[0] = args;
6948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6951 }
6952 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6953 {
6954 PyThreadState* __tstate = wxPyBeginAllowThreads();
6955 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6956 wxPyEndAllowThreads(__tstate);
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 resultobj = SWIG_From_int(static_cast< int >(result));
6960 return resultobj;
6961 fail:
6962 return NULL;
6963 }
6964
6965
6966 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6967 PyObject *resultobj = 0;
6968 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6969 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6970 void *argp1 = 0 ;
6971 int res1 = 0 ;
6972 void *argp2 = 0 ;
6973 int res2 = 0 ;
6974 PyObject * obj0 = 0 ;
6975 PyObject * obj1 = 0 ;
6976 char * kwnames[] = {
6977 (char *) "self",(char *) "defAttr", NULL
6978 };
6979
6980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6982 if (!SWIG_IsOK(res1)) {
6983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6984 }
6985 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6987 if (!SWIG_IsOK(res2)) {
6988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6989 }
6990 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6991 {
6992 PyThreadState* __tstate = wxPyBeginAllowThreads();
6993 (arg1)->SetDefAttr(arg2);
6994 wxPyEndAllowThreads(__tstate);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_Py_Void();
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *obj;
7006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7007 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7008 return SWIG_Py_Void();
7009 }
7010
7011 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7012 return SWIG_Python_InitShadowInstance(args);
7013 }
7014
7015 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7016 PyObject *resultobj = 0;
7017 wxGridCellAttrProvider *result = 0 ;
7018
7019 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 {
7027 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7028 }
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj = 0;
7037 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7038 PyObject *arg2 = (PyObject *) 0 ;
7039 void *argp1 = 0 ;
7040 int res1 = 0 ;
7041 PyObject * obj0 = 0 ;
7042 PyObject * obj1 = 0 ;
7043 char * kwnames[] = {
7044 (char *) "self",(char *) "_self", NULL
7045 };
7046
7047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7049 if (!SWIG_IsOK(res1)) {
7050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7051 }
7052 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7053 arg2 = obj1;
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 resultobj = SWIG_Py_Void();
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj = 0;
7069 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7070 int arg2 ;
7071 int arg3 ;
7072 wxGridCellAttr::wxAttrKind arg4 ;
7073 wxGridCellAttr *result = 0 ;
7074 void *argp1 = 0 ;
7075 int res1 = 0 ;
7076 int val2 ;
7077 int ecode2 = 0 ;
7078 int val3 ;
7079 int ecode3 = 0 ;
7080 int val4 ;
7081 int ecode4 = 0 ;
7082 PyObject * obj0 = 0 ;
7083 PyObject * obj1 = 0 ;
7084 PyObject * obj2 = 0 ;
7085 PyObject * obj3 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7092 if (!SWIG_IsOK(res1)) {
7093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7094 }
7095 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7096 ecode2 = SWIG_AsVal_int(obj1, &val2);
7097 if (!SWIG_IsOK(ecode2)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7099 }
7100 arg2 = static_cast< int >(val2);
7101 ecode3 = SWIG_AsVal_int(obj2, &val3);
7102 if (!SWIG_IsOK(ecode3)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7104 }
7105 arg3 = static_cast< int >(val3);
7106 ecode4 = SWIG_AsVal_int(obj3, &val4);
7107 if (!SWIG_IsOK(ecode4)) {
7108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7109 }
7110 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 {
7118 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7119 }
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj = 0;
7128 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7129 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7130 int arg3 ;
7131 int arg4 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 void *argp2 = 0 ;
7135 int res2 = 0 ;
7136 int val3 ;
7137 int ecode3 = 0 ;
7138 int val4 ;
7139 int ecode4 = 0 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 PyObject * obj2 = 0 ;
7143 PyObject * obj3 = 0 ;
7144 char * kwnames[] = {
7145 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7146 };
7147
7148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7150 if (!SWIG_IsOK(res1)) {
7151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7152 }
7153 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7155 if (!SWIG_IsOK(res2)) {
7156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7157 }
7158 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7159 ecode3 = SWIG_AsVal_int(obj2, &val3);
7160 if (!SWIG_IsOK(ecode3)) {
7161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7162 }
7163 arg3 = static_cast< int >(val3);
7164 ecode4 = SWIG_AsVal_int(obj3, &val4);
7165 if (!SWIG_IsOK(ecode4)) {
7166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7167 }
7168 arg4 = static_cast< int >(val4);
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 (arg1)->SetAttr(arg2,arg3,arg4);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_Py_Void();
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7185 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7186 int arg3 ;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 void *argp2 = 0 ;
7190 int res2 = 0 ;
7191 int val3 ;
7192 int ecode3 = 0 ;
7193 PyObject * obj0 = 0 ;
7194 PyObject * obj1 = 0 ;
7195 PyObject * obj2 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "attr",(char *) "row", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7204 }
7205 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7207 if (!SWIG_IsOK(res2)) {
7208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7209 }
7210 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7211 ecode3 = SWIG_AsVal_int(obj2, &val3);
7212 if (!SWIG_IsOK(ecode3)) {
7213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7214 }
7215 arg3 = static_cast< int >(val3);
7216 {
7217 PyThreadState* __tstate = wxPyBeginAllowThreads();
7218 (arg1)->SetRowAttr(arg2,arg3);
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 resultobj = SWIG_Py_Void();
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7230 PyObject *resultobj = 0;
7231 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7232 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7233 int arg3 ;
7234 void *argp1 = 0 ;
7235 int res1 = 0 ;
7236 void *argp2 = 0 ;
7237 int res2 = 0 ;
7238 int val3 ;
7239 int ecode3 = 0 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 PyObject * obj2 = 0 ;
7243 char * kwnames[] = {
7244 (char *) "self",(char *) "attr",(char *) "col", NULL
7245 };
7246
7247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7251 }
7252 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(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 '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7256 }
7257 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7258 ecode3 = SWIG_AsVal_int(obj2, &val3);
7259 if (!SWIG_IsOK(ecode3)) {
7260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7261 }
7262 arg3 = static_cast< int >(val3);
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->SetColAttr(arg2,arg3);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7279 size_t arg2 ;
7280 int arg3 ;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 size_t val2 ;
7284 int ecode2 = 0 ;
7285 int val3 ;
7286 int ecode3 = 0 ;
7287 PyObject * obj0 = 0 ;
7288 PyObject * obj1 = 0 ;
7289 PyObject * obj2 = 0 ;
7290 char * kwnames[] = {
7291 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7292 };
7293
7294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7296 if (!SWIG_IsOK(res1)) {
7297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7298 }
7299 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7300 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7301 if (!SWIG_IsOK(ecode2)) {
7302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7303 }
7304 arg2 = static_cast< size_t >(val2);
7305 ecode3 = SWIG_AsVal_int(obj2, &val3);
7306 if (!SWIG_IsOK(ecode3)) {
7307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7308 }
7309 arg3 = static_cast< int >(val3);
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 (arg1)->UpdateAttrRows(arg2,arg3);
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 resultobj = SWIG_Py_Void();
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7324 PyObject *resultobj = 0;
7325 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7326 size_t arg2 ;
7327 int arg3 ;
7328 void *argp1 = 0 ;
7329 int res1 = 0 ;
7330 size_t val2 ;
7331 int ecode2 = 0 ;
7332 int val3 ;
7333 int ecode3 = 0 ;
7334 PyObject * obj0 = 0 ;
7335 PyObject * obj1 = 0 ;
7336 PyObject * obj2 = 0 ;
7337 char * kwnames[] = {
7338 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7339 };
7340
7341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7343 if (!SWIG_IsOK(res1)) {
7344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7345 }
7346 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7347 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7348 if (!SWIG_IsOK(ecode2)) {
7349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7350 }
7351 arg2 = static_cast< size_t >(val2);
7352 ecode3 = SWIG_AsVal_int(obj2, &val3);
7353 if (!SWIG_IsOK(ecode3)) {
7354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7355 }
7356 arg3 = static_cast< int >(val3);
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 (arg1)->UpdateAttrCols(arg2,arg3);
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_Py_Void();
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *obj;
7372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7373 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7374 return SWIG_Py_Void();
7375 }
7376
7377 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7378 return SWIG_Python_InitShadowInstance(args);
7379 }
7380
7381 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7382 PyObject *resultobj = 0;
7383 wxPyGridCellAttrProvider *result = 0 ;
7384
7385 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7402 PyObject *arg2 = (PyObject *) 0 ;
7403 PyObject *arg3 = (PyObject *) 0 ;
7404 void *argp1 = 0 ;
7405 int res1 = 0 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 PyObject * obj2 = 0 ;
7409 char * kwnames[] = {
7410 (char *) "self",(char *) "self",(char *) "_class", NULL
7411 };
7412
7413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7415 if (!SWIG_IsOK(res1)) {
7416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7417 }
7418 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7419 arg2 = obj1;
7420 arg3 = obj2;
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 (arg1)->_setCallbackInfo(arg2,arg3);
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_Py_Void();
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj = 0;
7436 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7437 int arg2 ;
7438 int arg3 ;
7439 wxGridCellAttr::wxAttrKind arg4 ;
7440 wxGridCellAttr *result = 0 ;
7441 void *argp1 = 0 ;
7442 int res1 = 0 ;
7443 int val2 ;
7444 int ecode2 = 0 ;
7445 int val3 ;
7446 int ecode3 = 0 ;
7447 int val4 ;
7448 int ecode4 = 0 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 PyObject * obj2 = 0 ;
7452 PyObject * obj3 = 0 ;
7453 char * kwnames[] = {
7454 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7455 };
7456
7457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7459 if (!SWIG_IsOK(res1)) {
7460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7461 }
7462 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7463 ecode2 = SWIG_AsVal_int(obj1, &val2);
7464 if (!SWIG_IsOK(ecode2)) {
7465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7466 }
7467 arg2 = static_cast< int >(val2);
7468 ecode3 = SWIG_AsVal_int(obj2, &val3);
7469 if (!SWIG_IsOK(ecode3)) {
7470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7471 }
7472 arg3 = static_cast< int >(val3);
7473 ecode4 = SWIG_AsVal_int(obj3, &val4);
7474 if (!SWIG_IsOK(ecode4)) {
7475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7476 }
7477 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7496 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7497 int arg3 ;
7498 int arg4 ;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 void *argp2 = 0 ;
7502 int res2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 int val4 ;
7506 int ecode4 = 0 ;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 PyObject * obj2 = 0 ;
7510 PyObject * obj3 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7519 }
7520 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7522 if (!SWIG_IsOK(res2)) {
7523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7524 }
7525 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7526 ecode3 = SWIG_AsVal_int(obj2, &val3);
7527 if (!SWIG_IsOK(ecode3)) {
7528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7529 }
7530 arg3 = static_cast< int >(val3);
7531 ecode4 = SWIG_AsVal_int(obj3, &val4);
7532 if (!SWIG_IsOK(ecode4)) {
7533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7534 }
7535 arg4 = static_cast< int >(val4);
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->SetAttr(arg2,arg3,arg4);
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 resultobj = SWIG_Py_Void();
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj = 0;
7551 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7552 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7553 int arg3 ;
7554 void *argp1 = 0 ;
7555 int res1 = 0 ;
7556 void *argp2 = 0 ;
7557 int res2 = 0 ;
7558 int val3 ;
7559 int ecode3 = 0 ;
7560 PyObject * obj0 = 0 ;
7561 PyObject * obj1 = 0 ;
7562 PyObject * obj2 = 0 ;
7563 char * kwnames[] = {
7564 (char *) "self",(char *) "attr",(char *) "row", NULL
7565 };
7566
7567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7569 if (!SWIG_IsOK(res1)) {
7570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7571 }
7572 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7574 if (!SWIG_IsOK(res2)) {
7575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7576 }
7577 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7578 ecode3 = SWIG_AsVal_int(obj2, &val3);
7579 if (!SWIG_IsOK(ecode3)) {
7580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7581 }
7582 arg3 = static_cast< int >(val3);
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 (arg1)->SetRowAttr(arg2,arg3);
7586 wxPyEndAllowThreads(__tstate);
7587 if (PyErr_Occurred()) SWIG_fail;
7588 }
7589 resultobj = SWIG_Py_Void();
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj = 0;
7598 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7599 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7600 int arg3 ;
7601 void *argp1 = 0 ;
7602 int res1 = 0 ;
7603 void *argp2 = 0 ;
7604 int res2 = 0 ;
7605 int val3 ;
7606 int ecode3 = 0 ;
7607 PyObject * obj0 = 0 ;
7608 PyObject * obj1 = 0 ;
7609 PyObject * obj2 = 0 ;
7610 char * kwnames[] = {
7611 (char *) "self",(char *) "attr",(char *) "col", NULL
7612 };
7613
7614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7616 if (!SWIG_IsOK(res1)) {
7617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7618 }
7619 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7621 if (!SWIG_IsOK(res2)) {
7622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7623 }
7624 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7625 ecode3 = SWIG_AsVal_int(obj2, &val3);
7626 if (!SWIG_IsOK(ecode3)) {
7627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7628 }
7629 arg3 = static_cast< int >(val3);
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->SetColAttr(arg2,arg3);
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 resultobj = SWIG_Py_Void();
7637 return resultobj;
7638 fail:
7639 return NULL;
7640 }
7641
7642
7643 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7644 PyObject *obj;
7645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7646 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7647 return SWIG_Py_Void();
7648 }
7649
7650 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7651 return SWIG_Python_InitShadowInstance(args);
7652 }
7653
7654 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7655 PyObject *resultobj = 0;
7656 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 PyObject *swig_obj[1] ;
7660
7661 if (!args) SWIG_fail;
7662 swig_obj[0] = args;
7663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7666 }
7667 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7668 {
7669 PyThreadState* __tstate = wxPyBeginAllowThreads();
7670 delete arg1;
7671
7672 wxPyEndAllowThreads(__tstate);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 resultobj = SWIG_Py_Void();
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj = 0;
7684 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7685 PyObject *arg2 = (PyObject *) 0 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 char * kwnames[] = {
7691 (char *) "self",(char *) "_self", NULL
7692 };
7693
7694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7698 }
7699 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7700 arg2 = obj1;
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 wxGridTableBase__setOORInfo(arg1,arg2);
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 resultobj = SWIG_Py_Void();
7708 return resultobj;
7709 fail:
7710 return NULL;
7711 }
7712
7713
7714 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7715 PyObject *resultobj = 0;
7716 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7717 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7718 void *argp1 = 0 ;
7719 int res1 = 0 ;
7720 void *argp2 = 0 ;
7721 int res2 = 0 ;
7722 PyObject * obj0 = 0 ;
7723 PyObject * obj1 = 0 ;
7724 char * kwnames[] = {
7725 (char *) "self",(char *) "attrProvider", NULL
7726 };
7727
7728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7730 if (!SWIG_IsOK(res1)) {
7731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7732 }
7733 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7735 if (!SWIG_IsOK(res2)) {
7736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7737 }
7738 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 (arg1)->SetAttrProvider(arg2);
7742 wxPyEndAllowThreads(__tstate);
7743 if (PyErr_Occurred()) SWIG_fail;
7744 }
7745 resultobj = SWIG_Py_Void();
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7753 PyObject *resultobj = 0;
7754 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7755 wxGridCellAttrProvider *result = 0 ;
7756 void *argp1 = 0 ;
7757 int res1 = 0 ;
7758 PyObject *swig_obj[1] ;
7759
7760 if (!args) SWIG_fail;
7761 swig_obj[0] = args;
7762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7763 if (!SWIG_IsOK(res1)) {
7764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7765 }
7766 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 {
7774 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7775 }
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7783 PyObject *resultobj = 0;
7784 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7785 wxGrid *arg2 = (wxGrid *) 0 ;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 void *argp2 = 0 ;
7789 int res2 = 0 ;
7790 PyObject * obj0 = 0 ;
7791 PyObject * obj1 = 0 ;
7792 char * kwnames[] = {
7793 (char *) "self",(char *) "grid", NULL
7794 };
7795
7796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7800 }
7801 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7802 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7803 if (!SWIG_IsOK(res2)) {
7804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7805 }
7806 arg2 = reinterpret_cast< wxGrid * >(argp2);
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 (arg1)->SetView(arg2);
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 resultobj = SWIG_Py_Void();
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7821 PyObject *resultobj = 0;
7822 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7823 wxGrid *result = 0 ;
7824 void *argp1 = 0 ;
7825 int res1 = 0 ;
7826 PyObject *swig_obj[1] ;
7827
7828 if (!args) SWIG_fail;
7829 swig_obj[0] = args;
7830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7831 if (!SWIG_IsOK(res1)) {
7832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7833 }
7834 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7835 {
7836 PyThreadState* __tstate = wxPyBeginAllowThreads();
7837 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = wxPyMake_wxObject(result, (bool)0);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7851 PyObject *resultobj = 0;
7852 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7853 int result;
7854 void *argp1 = 0 ;
7855 int res1 = 0 ;
7856 PyObject *swig_obj[1] ;
7857
7858 if (!args) SWIG_fail;
7859 swig_obj[0] = args;
7860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7861 if (!SWIG_IsOK(res1)) {
7862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7863 }
7864 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7865 {
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 result = (int)(arg1)->GetNumberRows();
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 resultobj = SWIG_From_int(static_cast< int >(result));
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7879 PyObject *resultobj = 0;
7880 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7881 int result;
7882 void *argp1 = 0 ;
7883 int res1 = 0 ;
7884 PyObject *swig_obj[1] ;
7885
7886 if (!args) SWIG_fail;
7887 swig_obj[0] = args;
7888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7891 }
7892 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7893 {
7894 PyThreadState* __tstate = wxPyBeginAllowThreads();
7895 result = (int)(arg1)->GetNumberCols();
7896 wxPyEndAllowThreads(__tstate);
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 resultobj = SWIG_From_int(static_cast< int >(result));
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj = 0;
7908 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7909 int arg2 ;
7910 int arg3 ;
7911 bool result;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 int val2 ;
7915 int ecode2 = 0 ;
7916 int val3 ;
7917 int ecode3 = 0 ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 PyObject * obj2 = 0 ;
7921 char * kwnames[] = {
7922 (char *) "self",(char *) "row",(char *) "col", NULL
7923 };
7924
7925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7927 if (!SWIG_IsOK(res1)) {
7928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7929 }
7930 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7931 ecode2 = SWIG_AsVal_int(obj1, &val2);
7932 if (!SWIG_IsOK(ecode2)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7934 }
7935 arg2 = static_cast< int >(val2);
7936 ecode3 = SWIG_AsVal_int(obj2, &val3);
7937 if (!SWIG_IsOK(ecode3)) {
7938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7939 }
7940 arg3 = static_cast< int >(val3);
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7949 }
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj = 0;
7958 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7959 int arg2 ;
7960 int arg3 ;
7961 wxString result;
7962 void *argp1 = 0 ;
7963 int res1 = 0 ;
7964 int val2 ;
7965 int ecode2 = 0 ;
7966 int val3 ;
7967 int ecode3 = 0 ;
7968 PyObject * obj0 = 0 ;
7969 PyObject * obj1 = 0 ;
7970 PyObject * obj2 = 0 ;
7971 char * kwnames[] = {
7972 (char *) "self",(char *) "row",(char *) "col", NULL
7973 };
7974
7975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7977 if (!SWIG_IsOK(res1)) {
7978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7979 }
7980 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7981 ecode2 = SWIG_AsVal_int(obj1, &val2);
7982 if (!SWIG_IsOK(ecode2)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7984 }
7985 arg2 = static_cast< int >(val2);
7986 ecode3 = SWIG_AsVal_int(obj2, &val3);
7987 if (!SWIG_IsOK(ecode3)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7989 }
7990 arg3 = static_cast< int >(val3);
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 result = (arg1)->GetValue(arg2,arg3);
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 {
7998 #if wxUSE_UNICODE
7999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8000 #else
8001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8002 #endif
8003 }
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj = 0;
8012 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8013 int arg2 ;
8014 int arg3 ;
8015 wxString *arg4 = 0 ;
8016 void *argp1 = 0 ;
8017 int res1 = 0 ;
8018 int val2 ;
8019 int ecode2 = 0 ;
8020 int val3 ;
8021 int ecode3 = 0 ;
8022 bool temp4 = false ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 PyObject * obj2 = 0 ;
8026 PyObject * obj3 = 0 ;
8027 char * kwnames[] = {
8028 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8029 };
8030
8031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8033 if (!SWIG_IsOK(res1)) {
8034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8035 }
8036 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8037 ecode2 = SWIG_AsVal_int(obj1, &val2);
8038 if (!SWIG_IsOK(ecode2)) {
8039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8040 }
8041 arg2 = static_cast< int >(val2);
8042 ecode3 = SWIG_AsVal_int(obj2, &val3);
8043 if (!SWIG_IsOK(ecode3)) {
8044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8045 }
8046 arg3 = static_cast< int >(val3);
8047 {
8048 arg4 = wxString_in_helper(obj3);
8049 if (arg4 == NULL) SWIG_fail;
8050 temp4 = true;
8051 }
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 resultobj = SWIG_Py_Void();
8059 {
8060 if (temp4)
8061 delete arg4;
8062 }
8063 return resultobj;
8064 fail:
8065 {
8066 if (temp4)
8067 delete arg4;
8068 }
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8076 int arg2 ;
8077 int arg3 ;
8078 wxString result;
8079 void *argp1 = 0 ;
8080 int res1 = 0 ;
8081 int val2 ;
8082 int ecode2 = 0 ;
8083 int val3 ;
8084 int ecode3 = 0 ;
8085 PyObject * obj0 = 0 ;
8086 PyObject * obj1 = 0 ;
8087 PyObject * obj2 = 0 ;
8088 char * kwnames[] = {
8089 (char *) "self",(char *) "row",(char *) "col", NULL
8090 };
8091
8092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8094 if (!SWIG_IsOK(res1)) {
8095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8096 }
8097 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8098 ecode2 = SWIG_AsVal_int(obj1, &val2);
8099 if (!SWIG_IsOK(ecode2)) {
8100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8101 }
8102 arg2 = static_cast< int >(val2);
8103 ecode3 = SWIG_AsVal_int(obj2, &val3);
8104 if (!SWIG_IsOK(ecode3)) {
8105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8106 }
8107 arg3 = static_cast< int >(val3);
8108 {
8109 PyThreadState* __tstate = wxPyBeginAllowThreads();
8110 result = (arg1)->GetTypeName(arg2,arg3);
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 {
8115 #if wxUSE_UNICODE
8116 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8117 #else
8118 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8119 #endif
8120 }
8121 return resultobj;
8122 fail:
8123 return NULL;
8124 }
8125
8126
8127 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj = 0;
8129 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8130 int arg2 ;
8131 int arg3 ;
8132 wxString *arg4 = 0 ;
8133 bool result;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 int val2 ;
8137 int ecode2 = 0 ;
8138 int val3 ;
8139 int ecode3 = 0 ;
8140 bool temp4 = false ;
8141 PyObject * obj0 = 0 ;
8142 PyObject * obj1 = 0 ;
8143 PyObject * obj2 = 0 ;
8144 PyObject * obj3 = 0 ;
8145 char * kwnames[] = {
8146 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8147 };
8148
8149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8151 if (!SWIG_IsOK(res1)) {
8152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8153 }
8154 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8155 ecode2 = SWIG_AsVal_int(obj1, &val2);
8156 if (!SWIG_IsOK(ecode2)) {
8157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8158 }
8159 arg2 = static_cast< int >(val2);
8160 ecode3 = SWIG_AsVal_int(obj2, &val3);
8161 if (!SWIG_IsOK(ecode3)) {
8162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8163 }
8164 arg3 = static_cast< int >(val3);
8165 {
8166 arg4 = wxString_in_helper(obj3);
8167 if (arg4 == NULL) SWIG_fail;
8168 temp4 = true;
8169 }
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8178 }
8179 {
8180 if (temp4)
8181 delete arg4;
8182 }
8183 return resultobj;
8184 fail:
8185 {
8186 if (temp4)
8187 delete arg4;
8188 }
8189 return NULL;
8190 }
8191
8192
8193 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj = 0;
8195 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8196 int arg2 ;
8197 int arg3 ;
8198 wxString *arg4 = 0 ;
8199 bool result;
8200 void *argp1 = 0 ;
8201 int res1 = 0 ;
8202 int val2 ;
8203 int ecode2 = 0 ;
8204 int val3 ;
8205 int ecode3 = 0 ;
8206 bool temp4 = false ;
8207 PyObject * obj0 = 0 ;
8208 PyObject * obj1 = 0 ;
8209 PyObject * obj2 = 0 ;
8210 PyObject * obj3 = 0 ;
8211 char * kwnames[] = {
8212 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8213 };
8214
8215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8219 }
8220 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8221 ecode2 = SWIG_AsVal_int(obj1, &val2);
8222 if (!SWIG_IsOK(ecode2)) {
8223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8224 }
8225 arg2 = static_cast< int >(val2);
8226 ecode3 = SWIG_AsVal_int(obj2, &val3);
8227 if (!SWIG_IsOK(ecode3)) {
8228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8229 }
8230 arg3 = static_cast< int >(val3);
8231 {
8232 arg4 = wxString_in_helper(obj3);
8233 if (arg4 == NULL) SWIG_fail;
8234 temp4 = true;
8235 }
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 {
8243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8244 }
8245 {
8246 if (temp4)
8247 delete arg4;
8248 }
8249 return resultobj;
8250 fail:
8251 {
8252 if (temp4)
8253 delete arg4;
8254 }
8255 return NULL;
8256 }
8257
8258
8259 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8260 PyObject *resultobj = 0;
8261 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8262 int arg2 ;
8263 int arg3 ;
8264 long result;
8265 void *argp1 = 0 ;
8266 int res1 = 0 ;
8267 int val2 ;
8268 int ecode2 = 0 ;
8269 int val3 ;
8270 int ecode3 = 0 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 PyObject * obj2 = 0 ;
8274 char * kwnames[] = {
8275 (char *) "self",(char *) "row",(char *) "col", NULL
8276 };
8277
8278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8280 if (!SWIG_IsOK(res1)) {
8281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8282 }
8283 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8284 ecode2 = SWIG_AsVal_int(obj1, &val2);
8285 if (!SWIG_IsOK(ecode2)) {
8286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8287 }
8288 arg2 = static_cast< int >(val2);
8289 ecode3 = SWIG_AsVal_int(obj2, &val3);
8290 if (!SWIG_IsOK(ecode3)) {
8291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8292 }
8293 arg3 = static_cast< int >(val3);
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8297 wxPyEndAllowThreads(__tstate);
8298 if (PyErr_Occurred()) SWIG_fail;
8299 }
8300 resultobj = SWIG_From_long(static_cast< long >(result));
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj = 0;
8309 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8310 int arg2 ;
8311 int arg3 ;
8312 double result;
8313 void *argp1 = 0 ;
8314 int res1 = 0 ;
8315 int val2 ;
8316 int ecode2 = 0 ;
8317 int val3 ;
8318 int ecode3 = 0 ;
8319 PyObject * obj0 = 0 ;
8320 PyObject * obj1 = 0 ;
8321 PyObject * obj2 = 0 ;
8322 char * kwnames[] = {
8323 (char *) "self",(char *) "row",(char *) "col", NULL
8324 };
8325
8326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8328 if (!SWIG_IsOK(res1)) {
8329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8330 }
8331 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8332 ecode2 = SWIG_AsVal_int(obj1, &val2);
8333 if (!SWIG_IsOK(ecode2)) {
8334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8335 }
8336 arg2 = static_cast< int >(val2);
8337 ecode3 = SWIG_AsVal_int(obj2, &val3);
8338 if (!SWIG_IsOK(ecode3)) {
8339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8340 }
8341 arg3 = static_cast< int >(val3);
8342 {
8343 PyThreadState* __tstate = wxPyBeginAllowThreads();
8344 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 resultobj = SWIG_From_double(static_cast< double >(result));
8349 return resultobj;
8350 fail:
8351 return NULL;
8352 }
8353
8354
8355 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj = 0;
8357 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8358 int arg2 ;
8359 int arg3 ;
8360 bool result;
8361 void *argp1 = 0 ;
8362 int res1 = 0 ;
8363 int val2 ;
8364 int ecode2 = 0 ;
8365 int val3 ;
8366 int ecode3 = 0 ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 PyObject * obj2 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "row",(char *) "col", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8378 }
8379 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8380 ecode2 = SWIG_AsVal_int(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8383 }
8384 arg2 = static_cast< int >(val2);
8385 ecode3 = SWIG_AsVal_int(obj2, &val3);
8386 if (!SWIG_IsOK(ecode3)) {
8387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8388 }
8389 arg3 = static_cast< int >(val3);
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 {
8397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8398 }
8399 return resultobj;
8400 fail:
8401 return NULL;
8402 }
8403
8404
8405 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8406 PyObject *resultobj = 0;
8407 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8408 int arg2 ;
8409 int arg3 ;
8410 long arg4 ;
8411 void *argp1 = 0 ;
8412 int res1 = 0 ;
8413 int val2 ;
8414 int ecode2 = 0 ;
8415 int val3 ;
8416 int ecode3 = 0 ;
8417 long val4 ;
8418 int ecode4 = 0 ;
8419 PyObject * obj0 = 0 ;
8420 PyObject * obj1 = 0 ;
8421 PyObject * obj2 = 0 ;
8422 PyObject * obj3 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8431 }
8432 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8433 ecode2 = SWIG_AsVal_int(obj1, &val2);
8434 if (!SWIG_IsOK(ecode2)) {
8435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8436 }
8437 arg2 = static_cast< int >(val2);
8438 ecode3 = SWIG_AsVal_int(obj2, &val3);
8439 if (!SWIG_IsOK(ecode3)) {
8440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8441 }
8442 arg3 = static_cast< int >(val3);
8443 ecode4 = SWIG_AsVal_long(obj3, &val4);
8444 if (!SWIG_IsOK(ecode4)) {
8445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8446 }
8447 arg4 = static_cast< long >(val4);
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8451 wxPyEndAllowThreads(__tstate);
8452 if (PyErr_Occurred()) SWIG_fail;
8453 }
8454 resultobj = SWIG_Py_Void();
8455 return resultobj;
8456 fail:
8457 return NULL;
8458 }
8459
8460
8461 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8462 PyObject *resultobj = 0;
8463 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8464 int arg2 ;
8465 int arg3 ;
8466 double arg4 ;
8467 void *argp1 = 0 ;
8468 int res1 = 0 ;
8469 int val2 ;
8470 int ecode2 = 0 ;
8471 int val3 ;
8472 int ecode3 = 0 ;
8473 double val4 ;
8474 int ecode4 = 0 ;
8475 PyObject * obj0 = 0 ;
8476 PyObject * obj1 = 0 ;
8477 PyObject * obj2 = 0 ;
8478 PyObject * obj3 = 0 ;
8479 char * kwnames[] = {
8480 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8481 };
8482
8483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8487 }
8488 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8489 ecode2 = SWIG_AsVal_int(obj1, &val2);
8490 if (!SWIG_IsOK(ecode2)) {
8491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8492 }
8493 arg2 = static_cast< int >(val2);
8494 ecode3 = SWIG_AsVal_int(obj2, &val3);
8495 if (!SWIG_IsOK(ecode3)) {
8496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8497 }
8498 arg3 = static_cast< int >(val3);
8499 ecode4 = SWIG_AsVal_double(obj3, &val4);
8500 if (!SWIG_IsOK(ecode4)) {
8501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8502 }
8503 arg4 = static_cast< double >(val4);
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8507 wxPyEndAllowThreads(__tstate);
8508 if (PyErr_Occurred()) SWIG_fail;
8509 }
8510 resultobj = SWIG_Py_Void();
8511 return resultobj;
8512 fail:
8513 return NULL;
8514 }
8515
8516
8517 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8518 PyObject *resultobj = 0;
8519 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8520 int arg2 ;
8521 int arg3 ;
8522 bool arg4 ;
8523 void *argp1 = 0 ;
8524 int res1 = 0 ;
8525 int val2 ;
8526 int ecode2 = 0 ;
8527 int val3 ;
8528 int ecode3 = 0 ;
8529 bool val4 ;
8530 int ecode4 = 0 ;
8531 PyObject * obj0 = 0 ;
8532 PyObject * obj1 = 0 ;
8533 PyObject * obj2 = 0 ;
8534 PyObject * obj3 = 0 ;
8535 char * kwnames[] = {
8536 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8537 };
8538
8539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8543 }
8544 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8545 ecode2 = SWIG_AsVal_int(obj1, &val2);
8546 if (!SWIG_IsOK(ecode2)) {
8547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8548 }
8549 arg2 = static_cast< int >(val2);
8550 ecode3 = SWIG_AsVal_int(obj2, &val3);
8551 if (!SWIG_IsOK(ecode3)) {
8552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8553 }
8554 arg3 = static_cast< int >(val3);
8555 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8556 if (!SWIG_IsOK(ecode4)) {
8557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8558 }
8559 arg4 = static_cast< bool >(val4);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_Py_Void();
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8574 PyObject *resultobj = 0;
8575 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8576 void *argp1 = 0 ;
8577 int res1 = 0 ;
8578 PyObject *swig_obj[1] ;
8579
8580 if (!args) SWIG_fail;
8581 swig_obj[0] = args;
8582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8583 if (!SWIG_IsOK(res1)) {
8584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8585 }
8586 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8587 {
8588 PyThreadState* __tstate = wxPyBeginAllowThreads();
8589 (arg1)->Clear();
8590 wxPyEndAllowThreads(__tstate);
8591 if (PyErr_Occurred()) SWIG_fail;
8592 }
8593 resultobj = SWIG_Py_Void();
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj = 0;
8602 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8603 size_t arg2 = (size_t) 0 ;
8604 size_t arg3 = (size_t) 1 ;
8605 bool result;
8606 void *argp1 = 0 ;
8607 int res1 = 0 ;
8608 size_t val2 ;
8609 int ecode2 = 0 ;
8610 size_t val3 ;
8611 int ecode3 = 0 ;
8612 PyObject * obj0 = 0 ;
8613 PyObject * obj1 = 0 ;
8614 PyObject * obj2 = 0 ;
8615 char * kwnames[] = {
8616 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8617 };
8618
8619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8621 if (!SWIG_IsOK(res1)) {
8622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8623 }
8624 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8625 if (obj1) {
8626 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8627 if (!SWIG_IsOK(ecode2)) {
8628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8629 }
8630 arg2 = static_cast< size_t >(val2);
8631 }
8632 if (obj2) {
8633 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8634 if (!SWIG_IsOK(ecode3)) {
8635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8636 }
8637 arg3 = static_cast< size_t >(val3);
8638 }
8639 {
8640 PyThreadState* __tstate = wxPyBeginAllowThreads();
8641 result = (bool)(arg1)->InsertRows(arg2,arg3);
8642 wxPyEndAllowThreads(__tstate);
8643 if (PyErr_Occurred()) SWIG_fail;
8644 }
8645 {
8646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8647 }
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8657 size_t arg2 = (size_t) 1 ;
8658 bool result;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 size_t val2 ;
8662 int ecode2 = 0 ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char * kwnames[] = {
8666 (char *) "self",(char *) "numRows", NULL
8667 };
8668
8669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8671 if (!SWIG_IsOK(res1)) {
8672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8673 }
8674 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8675 if (obj1) {
8676 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8677 if (!SWIG_IsOK(ecode2)) {
8678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8679 }
8680 arg2 = static_cast< size_t >(val2);
8681 }
8682 {
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 result = (bool)(arg1)->AppendRows(arg2);
8685 wxPyEndAllowThreads(__tstate);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 {
8689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8690 }
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8698 PyObject *resultobj = 0;
8699 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8700 size_t arg2 = (size_t) 0 ;
8701 size_t arg3 = (size_t) 1 ;
8702 bool result;
8703 void *argp1 = 0 ;
8704 int res1 = 0 ;
8705 size_t val2 ;
8706 int ecode2 = 0 ;
8707 size_t val3 ;
8708 int ecode3 = 0 ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 PyObject * obj2 = 0 ;
8712 char * kwnames[] = {
8713 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8714 };
8715
8716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8718 if (!SWIG_IsOK(res1)) {
8719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8720 }
8721 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8722 if (obj1) {
8723 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8724 if (!SWIG_IsOK(ecode2)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8726 }
8727 arg2 = static_cast< size_t >(val2);
8728 }
8729 if (obj2) {
8730 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8731 if (!SWIG_IsOK(ecode3)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8733 }
8734 arg3 = static_cast< size_t >(val3);
8735 }
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = 0;
8753 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8754 size_t arg2 = (size_t) 0 ;
8755 size_t arg3 = (size_t) 1 ;
8756 bool result;
8757 void *argp1 = 0 ;
8758 int res1 = 0 ;
8759 size_t val2 ;
8760 int ecode2 = 0 ;
8761 size_t val3 ;
8762 int ecode3 = 0 ;
8763 PyObject * obj0 = 0 ;
8764 PyObject * obj1 = 0 ;
8765 PyObject * obj2 = 0 ;
8766 char * kwnames[] = {
8767 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8768 };
8769
8770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8772 if (!SWIG_IsOK(res1)) {
8773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8774 }
8775 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8776 if (obj1) {
8777 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8778 if (!SWIG_IsOK(ecode2)) {
8779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8780 }
8781 arg2 = static_cast< size_t >(val2);
8782 }
8783 if (obj2) {
8784 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8785 if (!SWIG_IsOK(ecode3)) {
8786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8787 }
8788 arg3 = static_cast< size_t >(val3);
8789 }
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (bool)(arg1)->InsertCols(arg2,arg3);
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 {
8797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8798 }
8799 return resultobj;
8800 fail:
8801 return NULL;
8802 }
8803
8804
8805 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj = 0;
8807 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8808 size_t arg2 = (size_t) 1 ;
8809 bool result;
8810 void *argp1 = 0 ;
8811 int res1 = 0 ;
8812 size_t val2 ;
8813 int ecode2 = 0 ;
8814 PyObject * obj0 = 0 ;
8815 PyObject * obj1 = 0 ;
8816 char * kwnames[] = {
8817 (char *) "self",(char *) "numCols", NULL
8818 };
8819
8820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8822 if (!SWIG_IsOK(res1)) {
8823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8824 }
8825 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8826 if (obj1) {
8827 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8828 if (!SWIG_IsOK(ecode2)) {
8829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8830 }
8831 arg2 = static_cast< size_t >(val2);
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 result = (bool)(arg1)->AppendCols(arg2);
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 {
8840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8841 }
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj = 0;
8850 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8851 size_t arg2 = (size_t) 0 ;
8852 size_t arg3 = (size_t) 1 ;
8853 bool result;
8854 void *argp1 = 0 ;
8855 int res1 = 0 ;
8856 size_t val2 ;
8857 int ecode2 = 0 ;
8858 size_t val3 ;
8859 int ecode3 = 0 ;
8860 PyObject * obj0 = 0 ;
8861 PyObject * obj1 = 0 ;
8862 PyObject * obj2 = 0 ;
8863 char * kwnames[] = {
8864 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8865 };
8866
8867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8869 if (!SWIG_IsOK(res1)) {
8870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8871 }
8872 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8873 if (obj1) {
8874 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8875 if (!SWIG_IsOK(ecode2)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8877 }
8878 arg2 = static_cast< size_t >(val2);
8879 }
8880 if (obj2) {
8881 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8882 if (!SWIG_IsOK(ecode3)) {
8883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8884 }
8885 arg3 = static_cast< size_t >(val3);
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8890 wxPyEndAllowThreads(__tstate);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 {
8894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8895 }
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj = 0;
8904 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8905 int arg2 ;
8906 wxString result;
8907 void *argp1 = 0 ;
8908 int res1 = 0 ;
8909 int val2 ;
8910 int ecode2 = 0 ;
8911 PyObject * obj0 = 0 ;
8912 PyObject * obj1 = 0 ;
8913 char * kwnames[] = {
8914 (char *) "self",(char *) "row", NULL
8915 };
8916
8917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8919 if (!SWIG_IsOK(res1)) {
8920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8921 }
8922 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8923 ecode2 = SWIG_AsVal_int(obj1, &val2);
8924 if (!SWIG_IsOK(ecode2)) {
8925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8926 }
8927 arg2 = static_cast< int >(val2);
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 result = (arg1)->GetRowLabelValue(arg2);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 {
8935 #if wxUSE_UNICODE
8936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8937 #else
8938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8939 #endif
8940 }
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj = 0;
8949 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8950 int arg2 ;
8951 wxString result;
8952 void *argp1 = 0 ;
8953 int res1 = 0 ;
8954 int val2 ;
8955 int ecode2 = 0 ;
8956 PyObject * obj0 = 0 ;
8957 PyObject * obj1 = 0 ;
8958 char * kwnames[] = {
8959 (char *) "self",(char *) "col", NULL
8960 };
8961
8962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8964 if (!SWIG_IsOK(res1)) {
8965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8966 }
8967 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8968 ecode2 = SWIG_AsVal_int(obj1, &val2);
8969 if (!SWIG_IsOK(ecode2)) {
8970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8971 }
8972 arg2 = static_cast< int >(val2);
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 result = (arg1)->GetColLabelValue(arg2);
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 {
8980 #if wxUSE_UNICODE
8981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8982 #else
8983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8984 #endif
8985 }
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj = 0;
8994 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8995 int arg2 ;
8996 wxString *arg3 = 0 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 int val2 ;
9000 int ecode2 = 0 ;
9001 bool temp3 = false ;
9002 PyObject * obj0 = 0 ;
9003 PyObject * obj1 = 0 ;
9004 PyObject * obj2 = 0 ;
9005 char * kwnames[] = {
9006 (char *) "self",(char *) "row",(char *) "value", NULL
9007 };
9008
9009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9011 if (!SWIG_IsOK(res1)) {
9012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9013 }
9014 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9015 ecode2 = SWIG_AsVal_int(obj1, &val2);
9016 if (!SWIG_IsOK(ecode2)) {
9017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9018 }
9019 arg2 = static_cast< int >(val2);
9020 {
9021 arg3 = wxString_in_helper(obj2);
9022 if (arg3 == NULL) SWIG_fail;
9023 temp3 = true;
9024 }
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 resultobj = SWIG_Py_Void();
9032 {
9033 if (temp3)
9034 delete arg3;
9035 }
9036 return resultobj;
9037 fail:
9038 {
9039 if (temp3)
9040 delete arg3;
9041 }
9042 return NULL;
9043 }
9044
9045
9046 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9049 int arg2 ;
9050 wxString *arg3 = 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 int val2 ;
9054 int ecode2 = 0 ;
9055 bool temp3 = false ;
9056 PyObject * obj0 = 0 ;
9057 PyObject * obj1 = 0 ;
9058 PyObject * obj2 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "col",(char *) "value", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9067 }
9068 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9069 ecode2 = SWIG_AsVal_int(obj1, &val2);
9070 if (!SWIG_IsOK(ecode2)) {
9071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9072 }
9073 arg2 = static_cast< int >(val2);
9074 {
9075 arg3 = wxString_in_helper(obj2);
9076 if (arg3 == NULL) SWIG_fail;
9077 temp3 = true;
9078 }
9079 {
9080 PyThreadState* __tstate = wxPyBeginAllowThreads();
9081 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 resultobj = SWIG_Py_Void();
9086 {
9087 if (temp3)
9088 delete arg3;
9089 }
9090 return resultobj;
9091 fail:
9092 {
9093 if (temp3)
9094 delete arg3;
9095 }
9096 return NULL;
9097 }
9098
9099
9100 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9101 PyObject *resultobj = 0;
9102 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9103 bool result;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 PyObject *swig_obj[1] ;
9107
9108 if (!args) SWIG_fail;
9109 swig_obj[0] = args;
9110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9113 }
9114 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 result = (bool)(arg1)->CanHaveAttributes();
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 {
9122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9123 }
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9131 PyObject *resultobj = 0;
9132 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9133 int arg2 ;
9134 int arg3 ;
9135 wxGridCellAttr::wxAttrKind arg4 ;
9136 wxGridCellAttr *result = 0 ;
9137 void *argp1 = 0 ;
9138 int res1 = 0 ;
9139 int val2 ;
9140 int ecode2 = 0 ;
9141 int val3 ;
9142 int ecode3 = 0 ;
9143 int val4 ;
9144 int ecode4 = 0 ;
9145 PyObject * obj0 = 0 ;
9146 PyObject * obj1 = 0 ;
9147 PyObject * obj2 = 0 ;
9148 PyObject * obj3 = 0 ;
9149 char * kwnames[] = {
9150 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9151 };
9152
9153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9155 if (!SWIG_IsOK(res1)) {
9156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9157 }
9158 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9159 ecode2 = SWIG_AsVal_int(obj1, &val2);
9160 if (!SWIG_IsOK(ecode2)) {
9161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9162 }
9163 arg2 = static_cast< int >(val2);
9164 ecode3 = SWIG_AsVal_int(obj2, &val3);
9165 if (!SWIG_IsOK(ecode3)) {
9166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9167 }
9168 arg3 = static_cast< int >(val3);
9169 ecode4 = SWIG_AsVal_int(obj3, &val4);
9170 if (!SWIG_IsOK(ecode4)) {
9171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9172 }
9173 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 {
9181 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9182 }
9183 return resultobj;
9184 fail:
9185 return NULL;
9186 }
9187
9188
9189 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj = 0;
9191 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9192 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9193 int arg3 ;
9194 int arg4 ;
9195 void *argp1 = 0 ;
9196 int res1 = 0 ;
9197 void *argp2 = 0 ;
9198 int res2 = 0 ;
9199 int val3 ;
9200 int ecode3 = 0 ;
9201 int val4 ;
9202 int ecode4 = 0 ;
9203 PyObject * obj0 = 0 ;
9204 PyObject * obj1 = 0 ;
9205 PyObject * obj2 = 0 ;
9206 PyObject * obj3 = 0 ;
9207 char * kwnames[] = {
9208 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9209 };
9210
9211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9213 if (!SWIG_IsOK(res1)) {
9214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9215 }
9216 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9218 if (!SWIG_IsOK(res2)) {
9219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9220 }
9221 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9222 ecode3 = SWIG_AsVal_int(obj2, &val3);
9223 if (!SWIG_IsOK(ecode3)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9225 }
9226 arg3 = static_cast< int >(val3);
9227 ecode4 = SWIG_AsVal_int(obj3, &val4);
9228 if (!SWIG_IsOK(ecode4)) {
9229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9230 }
9231 arg4 = static_cast< int >(val4);
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 (arg1)->SetAttr(arg2,arg3,arg4);
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 resultobj = SWIG_Py_Void();
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj = 0;
9247 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9248 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9249 int arg3 ;
9250 void *argp1 = 0 ;
9251 int res1 = 0 ;
9252 void *argp2 = 0 ;
9253 int res2 = 0 ;
9254 int val3 ;
9255 int ecode3 = 0 ;
9256 PyObject * obj0 = 0 ;
9257 PyObject * obj1 = 0 ;
9258 PyObject * obj2 = 0 ;
9259 char * kwnames[] = {
9260 (char *) "self",(char *) "attr",(char *) "row", NULL
9261 };
9262
9263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9267 }
9268 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9270 if (!SWIG_IsOK(res2)) {
9271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9272 }
9273 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9274 ecode3 = SWIG_AsVal_int(obj2, &val3);
9275 if (!SWIG_IsOK(ecode3)) {
9276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9277 }
9278 arg3 = static_cast< int >(val3);
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 (arg1)->SetRowAttr(arg2,arg3);
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 resultobj = SWIG_Py_Void();
9286 return resultobj;
9287 fail:
9288 return NULL;
9289 }
9290
9291
9292 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj = 0;
9294 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9295 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9296 int arg3 ;
9297 void *argp1 = 0 ;
9298 int res1 = 0 ;
9299 void *argp2 = 0 ;
9300 int res2 = 0 ;
9301 int val3 ;
9302 int ecode3 = 0 ;
9303 PyObject * obj0 = 0 ;
9304 PyObject * obj1 = 0 ;
9305 PyObject * obj2 = 0 ;
9306 char * kwnames[] = {
9307 (char *) "self",(char *) "attr",(char *) "col", NULL
9308 };
9309
9310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9314 }
9315 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9317 if (!SWIG_IsOK(res2)) {
9318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9319 }
9320 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9321 ecode3 = SWIG_AsVal_int(obj2, &val3);
9322 if (!SWIG_IsOK(ecode3)) {
9323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9324 }
9325 arg3 = static_cast< int >(val3);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->SetColAttr(arg2,arg3);
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *obj;
9341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9342 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9343 return SWIG_Py_Void();
9344 }
9345
9346 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9347 PyObject *resultobj = 0;
9348 wxPyGridTableBase *result = 0 ;
9349
9350 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj = 0;
9366 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9367 PyObject *arg2 = (PyObject *) 0 ;
9368 PyObject *arg3 = (PyObject *) 0 ;
9369 void *argp1 = 0 ;
9370 int res1 = 0 ;
9371 PyObject * obj0 = 0 ;
9372 PyObject * obj1 = 0 ;
9373 PyObject * obj2 = 0 ;
9374 char * kwnames[] = {
9375 (char *) "self",(char *) "self",(char *) "_class", NULL
9376 };
9377
9378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9382 }
9383 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9384 arg2 = obj1;
9385 arg3 = obj2;
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 (arg1)->_setCallbackInfo(arg2,arg3);
9389 wxPyEndAllowThreads(__tstate);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_Py_Void();
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 PyObject *swig_obj[1] ;
9405
9406 if (!args) SWIG_fail;
9407 swig_obj[0] = args;
9408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9409 if (!SWIG_IsOK(res1)) {
9410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9411 }
9412 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 wxPyGridTableBase_Destroy(arg1);
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_Py_Void();
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 PyObject *obj;
9428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9429 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9430 return SWIG_Py_Void();
9431 }
9432
9433 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434 return SWIG_Python_InitShadowInstance(args);
9435 }
9436
9437 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 int arg1 = (int) 0 ;
9440 int arg2 = (int) 0 ;
9441 wxGridStringTable *result = 0 ;
9442 int val1 ;
9443 int ecode1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "numRows",(char *) "numCols", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9453 if (obj0) {
9454 ecode1 = SWIG_AsVal_int(obj0, &val1);
9455 if (!SWIG_IsOK(ecode1)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9457 }
9458 arg1 = static_cast< int >(val1);
9459 }
9460 if (obj1) {
9461 ecode2 = SWIG_AsVal_int(obj1, &val2);
9462 if (!SWIG_IsOK(ecode2)) {
9463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9464 }
9465 arg2 = static_cast< int >(val2);
9466 }
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *obj;
9482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9483 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9484 return SWIG_Py_Void();
9485 }
9486
9487 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9488 return SWIG_Python_InitShadowInstance(args);
9489 }
9490
9491 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj = 0;
9493 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9494 int arg2 ;
9495 int arg3 = (int) -1 ;
9496 int arg4 = (int) -1 ;
9497 wxGridTableMessage *result = 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 int val2 ;
9501 int ecode2 = 0 ;
9502 int val3 ;
9503 int ecode3 = 0 ;
9504 int val4 ;
9505 int ecode4 = 0 ;
9506 PyObject * obj0 = 0 ;
9507 PyObject * obj1 = 0 ;
9508 PyObject * obj2 = 0 ;
9509 PyObject * obj3 = 0 ;
9510 char * kwnames[] = {
9511 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9512 };
9513
9514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9516 if (!SWIG_IsOK(res1)) {
9517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9518 }
9519 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9520 ecode2 = SWIG_AsVal_int(obj1, &val2);
9521 if (!SWIG_IsOK(ecode2)) {
9522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9523 }
9524 arg2 = static_cast< int >(val2);
9525 if (obj2) {
9526 ecode3 = SWIG_AsVal_int(obj2, &val3);
9527 if (!SWIG_IsOK(ecode3)) {
9528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9529 }
9530 arg3 = static_cast< int >(val3);
9531 }
9532 if (obj3) {
9533 ecode4 = SWIG_AsVal_int(obj3, &val4);
9534 if (!SWIG_IsOK(ecode4)) {
9535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9536 }
9537 arg4 = static_cast< int >(val4);
9538 }
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9542 wxPyEndAllowThreads(__tstate);
9543 if (PyErr_Occurred()) SWIG_fail;
9544 }
9545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9546 return resultobj;
9547 fail:
9548 return NULL;
9549 }
9550
9551
9552 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9553 PyObject *resultobj = 0;
9554 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9555 void *argp1 = 0 ;
9556 int res1 = 0 ;
9557 PyObject *swig_obj[1] ;
9558
9559 if (!args) SWIG_fail;
9560 swig_obj[0] = args;
9561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9562 if (!SWIG_IsOK(res1)) {
9563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9564 }
9565 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 delete arg1;
9569
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 resultobj = SWIG_Py_Void();
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = 0;
9582 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9583 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 void *argp2 = 0 ;
9587 int res2 = 0 ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9590 char * kwnames[] = {
9591 (char *) "self",(char *) "table", NULL
9592 };
9593
9594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9596 if (!SWIG_IsOK(res1)) {
9597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9598 }
9599 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9601 if (!SWIG_IsOK(res2)) {
9602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9603 }
9604 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 (arg1)->SetTableObject(arg2);
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_Py_Void();
9612 return resultobj;
9613 fail:
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9621 wxGridTableBase *result = 0 ;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject *swig_obj[1] ;
9625
9626 if (!args) SWIG_fail;
9627 swig_obj[0] = args;
9628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9629 if (!SWIG_IsOK(res1)) {
9630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9631 }
9632 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 {
9640 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9641 }
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj = 0;
9650 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9651 int arg2 ;
9652 void *argp1 = 0 ;
9653 int res1 = 0 ;
9654 int val2 ;
9655 int ecode2 = 0 ;
9656 PyObject * obj0 = 0 ;
9657 PyObject * obj1 = 0 ;
9658 char * kwnames[] = {
9659 (char *) "self",(char *) "id", NULL
9660 };
9661
9662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9664 if (!SWIG_IsOK(res1)) {
9665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9666 }
9667 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9668 ecode2 = SWIG_AsVal_int(obj1, &val2);
9669 if (!SWIG_IsOK(ecode2)) {
9670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9671 }
9672 arg2 = static_cast< int >(val2);
9673 {
9674 PyThreadState* __tstate = wxPyBeginAllowThreads();
9675 (arg1)->SetId(arg2);
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 resultobj = SWIG_Py_Void();
9680 return resultobj;
9681 fail:
9682 return NULL;
9683 }
9684
9685
9686 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9687 PyObject *resultobj = 0;
9688 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9689 int result;
9690 void *argp1 = 0 ;
9691 int res1 = 0 ;
9692 PyObject *swig_obj[1] ;
9693
9694 if (!args) SWIG_fail;
9695 swig_obj[0] = args;
9696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9699 }
9700 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 result = (int)(arg1)->GetId();
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_From_int(static_cast< int >(result));
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9715 PyObject *resultobj = 0;
9716 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9717 int arg2 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 int val2 ;
9721 int ecode2 = 0 ;
9722 PyObject * obj0 = 0 ;
9723 PyObject * obj1 = 0 ;
9724 char * kwnames[] = {
9725 (char *) "self",(char *) "comInt1", NULL
9726 };
9727
9728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9732 }
9733 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9734 ecode2 = SWIG_AsVal_int(obj1, &val2);
9735 if (!SWIG_IsOK(ecode2)) {
9736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9737 }
9738 arg2 = static_cast< int >(val2);
9739 {
9740 PyThreadState* __tstate = wxPyBeginAllowThreads();
9741 (arg1)->SetCommandInt(arg2);
9742 wxPyEndAllowThreads(__tstate);
9743 if (PyErr_Occurred()) SWIG_fail;
9744 }
9745 resultobj = SWIG_Py_Void();
9746 return resultobj;
9747 fail:
9748 return NULL;
9749 }
9750
9751
9752 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9753 PyObject *resultobj = 0;
9754 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9755 int result;
9756 void *argp1 = 0 ;
9757 int res1 = 0 ;
9758 PyObject *swig_obj[1] ;
9759
9760 if (!args) SWIG_fail;
9761 swig_obj[0] = args;
9762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9763 if (!SWIG_IsOK(res1)) {
9764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9765 }
9766 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 result = (int)(arg1)->GetCommandInt();
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 resultobj = SWIG_From_int(static_cast< int >(result));
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj = 0;
9782 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9783 int arg2 ;
9784 void *argp1 = 0 ;
9785 int res1 = 0 ;
9786 int val2 ;
9787 int ecode2 = 0 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char * kwnames[] = {
9791 (char *) "self",(char *) "comInt2", NULL
9792 };
9793
9794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9798 }
9799 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9800 ecode2 = SWIG_AsVal_int(obj1, &val2);
9801 if (!SWIG_IsOK(ecode2)) {
9802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9803 }
9804 arg2 = static_cast< int >(val2);
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 (arg1)->SetCommandInt2(arg2);
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 resultobj = SWIG_Py_Void();
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9819 PyObject *resultobj = 0;
9820 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9821 int result;
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, 0 | 0 );
9829 if (!SWIG_IsOK(res1)) {
9830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9831 }
9832 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (int)(arg1)->GetCommandInt2();
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_From_int(static_cast< int >(result));
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *obj;
9848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9849 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9850 return SWIG_Py_Void();
9851 }
9852
9853 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9854 return SWIG_Python_InitShadowInstance(args);
9855 }
9856
9857 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 int arg1 = (int) -1 ;
9860 int arg2 = (int) -1 ;
9861 wxGridCellCoords *result = 0 ;
9862 int val1 ;
9863 int ecode1 = 0 ;
9864 int val2 ;
9865 int ecode2 = 0 ;
9866 PyObject * obj0 = 0 ;
9867 PyObject * obj1 = 0 ;
9868 char * kwnames[] = {
9869 (char *) "r",(char *) "c", NULL
9870 };
9871
9872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9873 if (obj0) {
9874 ecode1 = SWIG_AsVal_int(obj0, &val1);
9875 if (!SWIG_IsOK(ecode1)) {
9876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9877 }
9878 arg1 = static_cast< int >(val1);
9879 }
9880 if (obj1) {
9881 ecode2 = SWIG_AsVal_int(obj1, &val2);
9882 if (!SWIG_IsOK(ecode2)) {
9883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9884 }
9885 arg2 = static_cast< int >(val2);
9886 }
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9894 return resultobj;
9895 fail:
9896 return NULL;
9897 }
9898
9899
9900 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 PyObject *resultobj = 0;
9902 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 PyObject *swig_obj[1] ;
9906
9907 if (!args) SWIG_fail;
9908 swig_obj[0] = args;
9909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9910 if (!SWIG_IsOK(res1)) {
9911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9912 }
9913 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 delete arg1;
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 resultobj = SWIG_Py_Void();
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *resultobj = 0;
9930 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9931 int result;
9932 void *argp1 = 0 ;
9933 int res1 = 0 ;
9934 PyObject *swig_obj[1] ;
9935
9936 if (!args) SWIG_fail;
9937 swig_obj[0] = args;
9938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9939 if (!SWIG_IsOK(res1)) {
9940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9941 }
9942 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9943 {
9944 PyThreadState* __tstate = wxPyBeginAllowThreads();
9945 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9946 wxPyEndAllowThreads(__tstate);
9947 if (PyErr_Occurred()) SWIG_fail;
9948 }
9949 resultobj = SWIG_From_int(static_cast< int >(result));
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9957 PyObject *resultobj = 0;
9958 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9959 int arg2 ;
9960 void *argp1 = 0 ;
9961 int res1 = 0 ;
9962 int val2 ;
9963 int ecode2 = 0 ;
9964 PyObject * obj0 = 0 ;
9965 PyObject * obj1 = 0 ;
9966 char * kwnames[] = {
9967 (char *) "self",(char *) "n", NULL
9968 };
9969
9970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9972 if (!SWIG_IsOK(res1)) {
9973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9974 }
9975 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9976 ecode2 = SWIG_AsVal_int(obj1, &val2);
9977 if (!SWIG_IsOK(ecode2)) {
9978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9979 }
9980 arg2 = static_cast< int >(val2);
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 (arg1)->SetRow(arg2);
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 resultobj = SWIG_Py_Void();
9988 return resultobj;
9989 fail:
9990 return NULL;
9991 }
9992
9993
9994 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9995 PyObject *resultobj = 0;
9996 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9997 int result;
9998 void *argp1 = 0 ;
9999 int res1 = 0 ;
10000 PyObject *swig_obj[1] ;
10001
10002 if (!args) SWIG_fail;
10003 swig_obj[0] = args;
10004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10005 if (!SWIG_IsOK(res1)) {
10006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10007 }
10008 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10009 {
10010 PyThreadState* __tstate = wxPyBeginAllowThreads();
10011 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10012 wxPyEndAllowThreads(__tstate);
10013 if (PyErr_Occurred()) SWIG_fail;
10014 }
10015 resultobj = SWIG_From_int(static_cast< int >(result));
10016 return resultobj;
10017 fail:
10018 return NULL;
10019 }
10020
10021
10022 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10023 PyObject *resultobj = 0;
10024 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10025 int arg2 ;
10026 void *argp1 = 0 ;
10027 int res1 = 0 ;
10028 int val2 ;
10029 int ecode2 = 0 ;
10030 PyObject * obj0 = 0 ;
10031 PyObject * obj1 = 0 ;
10032 char * kwnames[] = {
10033 (char *) "self",(char *) "n", NULL
10034 };
10035
10036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10040 }
10041 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10042 ecode2 = SWIG_AsVal_int(obj1, &val2);
10043 if (!SWIG_IsOK(ecode2)) {
10044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10045 }
10046 arg2 = static_cast< int >(val2);
10047 {
10048 PyThreadState* __tstate = wxPyBeginAllowThreads();
10049 (arg1)->SetCol(arg2);
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 resultobj = SWIG_Py_Void();
10054 return resultobj;
10055 fail:
10056 return NULL;
10057 }
10058
10059
10060 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj = 0;
10062 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10063 int arg2 ;
10064 int arg3 ;
10065 void *argp1 = 0 ;
10066 int res1 = 0 ;
10067 int val2 ;
10068 int ecode2 = 0 ;
10069 int val3 ;
10070 int ecode3 = 0 ;
10071 PyObject * obj0 = 0 ;
10072 PyObject * obj1 = 0 ;
10073 PyObject * obj2 = 0 ;
10074 char * kwnames[] = {
10075 (char *) "self",(char *) "row",(char *) "col", NULL
10076 };
10077
10078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10080 if (!SWIG_IsOK(res1)) {
10081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10082 }
10083 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10084 ecode2 = SWIG_AsVal_int(obj1, &val2);
10085 if (!SWIG_IsOK(ecode2)) {
10086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10087 }
10088 arg2 = static_cast< int >(val2);
10089 ecode3 = SWIG_AsVal_int(obj2, &val3);
10090 if (!SWIG_IsOK(ecode3)) {
10091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10092 }
10093 arg3 = static_cast< int >(val3);
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 (arg1)->Set(arg2,arg3);
10097 wxPyEndAllowThreads(__tstate);
10098 if (PyErr_Occurred()) SWIG_fail;
10099 }
10100 resultobj = SWIG_Py_Void();
10101 return resultobj;
10102 fail:
10103 return NULL;
10104 }
10105
10106
10107 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10108 PyObject *resultobj = 0;
10109 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10110 PyObject *arg2 = (PyObject *) 0 ;
10111 bool result;
10112 void *argp1 = 0 ;
10113 int res1 = 0 ;
10114 PyObject * obj0 = 0 ;
10115 PyObject * obj1 = 0 ;
10116 char * kwnames[] = {
10117 (char *) "self",(char *) "other", NULL
10118 };
10119
10120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10122 if (!SWIG_IsOK(res1)) {
10123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10124 }
10125 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10126 arg2 = obj1;
10127 {
10128 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 {
10132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10133 }
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10141 PyObject *resultobj = 0;
10142 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10143 PyObject *arg2 = (PyObject *) 0 ;
10144 bool result;
10145 void *argp1 = 0 ;
10146 int res1 = 0 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 char * kwnames[] = {
10150 (char *) "self",(char *) "other", NULL
10151 };
10152
10153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10157 }
10158 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10159 arg2 = obj1;
10160 {
10161 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10166 }
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10174 PyObject *resultobj = 0;
10175 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10176 PyObject *result = 0 ;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 PyObject *swig_obj[1] ;
10180
10181 if (!args) SWIG_fail;
10182 swig_obj[0] = args;
10183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10186 }
10187 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (PyObject *)wxGridCellCoords_Get(arg1);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 resultobj = result;
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 PyObject *obj;
10203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10204 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10205 return SWIG_Py_Void();
10206 }
10207
10208 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10209 return SWIG_Python_InitShadowInstance(args);
10210 }
10211
10212 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10213 PyObject *resultobj = 0;
10214 wxWindow *arg1 = (wxWindow *) 0 ;
10215 int arg2 = (int) -1 ;
10216 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10217 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10218 wxSize const &arg4_defvalue = wxDefaultSize ;
10219 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10220 long arg5 = (long) wxWANTS_CHARS ;
10221 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10222 wxString *arg6 = (wxString *) &arg6_defvalue ;
10223 wxGrid *result = 0 ;
10224 void *argp1 = 0 ;
10225 int res1 = 0 ;
10226 int val2 ;
10227 int ecode2 = 0 ;
10228 wxPoint temp3 ;
10229 wxSize temp4 ;
10230 long val5 ;
10231 int ecode5 = 0 ;
10232 bool temp6 = false ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 PyObject * obj3 = 0 ;
10237 PyObject * obj4 = 0 ;
10238 PyObject * obj5 = 0 ;
10239 char * kwnames[] = {
10240 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10241 };
10242
10243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10245 if (!SWIG_IsOK(res1)) {
10246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10247 }
10248 arg1 = reinterpret_cast< wxWindow * >(argp1);
10249 if (obj1) {
10250 ecode2 = SWIG_AsVal_int(obj1, &val2);
10251 if (!SWIG_IsOK(ecode2)) {
10252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10253 }
10254 arg2 = static_cast< int >(val2);
10255 }
10256 if (obj2) {
10257 {
10258 arg3 = &temp3;
10259 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10260 }
10261 }
10262 if (obj3) {
10263 {
10264 arg4 = &temp4;
10265 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10266 }
10267 }
10268 if (obj4) {
10269 ecode5 = SWIG_AsVal_long(obj4, &val5);
10270 if (!SWIG_IsOK(ecode5)) {
10271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10272 }
10273 arg5 = static_cast< long >(val5);
10274 }
10275 if (obj5) {
10276 {
10277 arg6 = wxString_in_helper(obj5);
10278 if (arg6 == NULL) SWIG_fail;
10279 temp6 = true;
10280 }
10281 }
10282 {
10283 if (!wxPyCheckForApp()) SWIG_fail;
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10290 {
10291 if (temp6)
10292 delete arg6;
10293 }
10294 return resultobj;
10295 fail:
10296 {
10297 if (temp6)
10298 delete arg6;
10299 }
10300 return NULL;
10301 }
10302
10303
10304 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10305 PyObject *resultobj = 0;
10306 wxGrid *result = 0 ;
10307
10308 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10309 {
10310 if (!wxPyCheckForApp()) SWIG_fail;
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 result = (wxGrid *)new wxGrid();
10313 wxPyEndAllowThreads(__tstate);
10314 if (PyErr_Occurred()) SWIG_fail;
10315 }
10316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10317 return resultobj;
10318 fail:
10319 return NULL;
10320 }
10321
10322
10323 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj = 0;
10325 wxGrid *arg1 = (wxGrid *) 0 ;
10326 wxWindow *arg2 = (wxWindow *) 0 ;
10327 int arg3 = (int) -1 ;
10328 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10329 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10330 wxSize const &arg5_defvalue = wxDefaultSize ;
10331 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10332 long arg6 = (long) wxWANTS_CHARS ;
10333 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10334 wxString *arg7 = (wxString *) &arg7_defvalue ;
10335 bool result;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 void *argp2 = 0 ;
10339 int res2 = 0 ;
10340 int val3 ;
10341 int ecode3 = 0 ;
10342 wxPoint temp4 ;
10343 wxSize temp5 ;
10344 long val6 ;
10345 int ecode6 = 0 ;
10346 bool temp7 = false ;
10347 PyObject * obj0 = 0 ;
10348 PyObject * obj1 = 0 ;
10349 PyObject * obj2 = 0 ;
10350 PyObject * obj3 = 0 ;
10351 PyObject * obj4 = 0 ;
10352 PyObject * obj5 = 0 ;
10353 PyObject * obj6 = 0 ;
10354 char * kwnames[] = {
10355 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10356 };
10357
10358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10362 }
10363 arg1 = reinterpret_cast< wxGrid * >(argp1);
10364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10365 if (!SWIG_IsOK(res2)) {
10366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10367 }
10368 arg2 = reinterpret_cast< wxWindow * >(argp2);
10369 if (obj2) {
10370 ecode3 = SWIG_AsVal_int(obj2, &val3);
10371 if (!SWIG_IsOK(ecode3)) {
10372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10373 }
10374 arg3 = static_cast< int >(val3);
10375 }
10376 if (obj3) {
10377 {
10378 arg4 = &temp4;
10379 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10380 }
10381 }
10382 if (obj4) {
10383 {
10384 arg5 = &temp5;
10385 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10386 }
10387 }
10388 if (obj5) {
10389 ecode6 = SWIG_AsVal_long(obj5, &val6);
10390 if (!SWIG_IsOK(ecode6)) {
10391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10392 }
10393 arg6 = static_cast< long >(val6);
10394 }
10395 if (obj6) {
10396 {
10397 arg7 = wxString_in_helper(obj6);
10398 if (arg7 == NULL) SWIG_fail;
10399 temp7 = true;
10400 }
10401 }
10402 {
10403 PyThreadState* __tstate = wxPyBeginAllowThreads();
10404 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 {
10409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10410 }
10411 {
10412 if (temp7)
10413 delete arg7;
10414 }
10415 return resultobj;
10416 fail:
10417 {
10418 if (temp7)
10419 delete arg7;
10420 }
10421 return NULL;
10422 }
10423
10424
10425 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10426 PyObject *resultobj = 0;
10427 wxGrid *arg1 = (wxGrid *) 0 ;
10428 int arg2 ;
10429 int arg3 ;
10430 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10431 bool result;
10432 void *argp1 = 0 ;
10433 int res1 = 0 ;
10434 int val2 ;
10435 int ecode2 = 0 ;
10436 int val3 ;
10437 int ecode3 = 0 ;
10438 int val4 ;
10439 int ecode4 = 0 ;
10440 PyObject * obj0 = 0 ;
10441 PyObject * obj1 = 0 ;
10442 PyObject * obj2 = 0 ;
10443 PyObject * obj3 = 0 ;
10444 char * kwnames[] = {
10445 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10446 };
10447
10448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10450 if (!SWIG_IsOK(res1)) {
10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10452 }
10453 arg1 = reinterpret_cast< wxGrid * >(argp1);
10454 ecode2 = SWIG_AsVal_int(obj1, &val2);
10455 if (!SWIG_IsOK(ecode2)) {
10456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10457 }
10458 arg2 = static_cast< int >(val2);
10459 ecode3 = SWIG_AsVal_int(obj2, &val3);
10460 if (!SWIG_IsOK(ecode3)) {
10461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10462 }
10463 arg3 = static_cast< int >(val3);
10464 if (obj3) {
10465 ecode4 = SWIG_AsVal_int(obj3, &val4);
10466 if (!SWIG_IsOK(ecode4)) {
10467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10468 }
10469 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10470 }
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 {
10478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10479 }
10480 return resultobj;
10481 fail:
10482 return NULL;
10483 }
10484
10485
10486 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10487 PyObject *resultobj = 0;
10488 wxGrid *arg1 = (wxGrid *) 0 ;
10489 WXGRIDSELECTIONMODES arg2 ;
10490 void *argp1 = 0 ;
10491 int res1 = 0 ;
10492 int val2 ;
10493 int ecode2 = 0 ;
10494 PyObject * obj0 = 0 ;
10495 PyObject * obj1 = 0 ;
10496 char * kwnames[] = {
10497 (char *) "self",(char *) "selmode", NULL
10498 };
10499
10500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10504 }
10505 arg1 = reinterpret_cast< wxGrid * >(argp1);
10506 ecode2 = SWIG_AsVal_int(obj1, &val2);
10507 if (!SWIG_IsOK(ecode2)) {
10508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10509 }
10510 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 (arg1)->SetSelectionMode(arg2);
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 resultobj = SWIG_Py_Void();
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10525 PyObject *resultobj = 0;
10526 wxGrid *arg1 = (wxGrid *) 0 ;
10527 WXGRIDSELECTIONMODES result;
10528 void *argp1 = 0 ;
10529 int res1 = 0 ;
10530 PyObject *swig_obj[1] ;
10531
10532 if (!args) SWIG_fail;
10533 swig_obj[0] = args;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10537 }
10538 arg1 = reinterpret_cast< wxGrid * >(argp1);
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10542 wxPyEndAllowThreads(__tstate);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 resultobj = SWIG_From_int(static_cast< int >(result));
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *resultobj = 0;
10554 wxGrid *arg1 = (wxGrid *) 0 ;
10555 int result;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 PyObject *swig_obj[1] ;
10559
10560 if (!args) SWIG_fail;
10561 swig_obj[0] = args;
10562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10565 }
10566 arg1 = reinterpret_cast< wxGrid * >(argp1);
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (int)(arg1)->GetNumberRows();
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 resultobj = SWIG_From_int(static_cast< int >(result));
10574 return resultobj;
10575 fail:
10576 return NULL;
10577 }
10578
10579
10580 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10581 PyObject *resultobj = 0;
10582 wxGrid *arg1 = (wxGrid *) 0 ;
10583 int result;
10584 void *argp1 = 0 ;
10585 int res1 = 0 ;
10586 PyObject *swig_obj[1] ;
10587
10588 if (!args) SWIG_fail;
10589 swig_obj[0] = args;
10590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10591 if (!SWIG_IsOK(res1)) {
10592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10593 }
10594 arg1 = reinterpret_cast< wxGrid * >(argp1);
10595 {
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (int)(arg1)->GetNumberCols();
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 resultobj = SWIG_From_int(static_cast< int >(result));
10602 return resultobj;
10603 fail:
10604 return NULL;
10605 }
10606
10607
10608 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10609 PyObject *resultobj = 0;
10610 wxGrid *arg1 = (wxGrid *) 0 ;
10611 wxGridTableMessage *arg2 = 0 ;
10612 bool result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 void *argp2 = 0 ;
10616 int res2 = 0 ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 char * kwnames[] = {
10620 (char *) "self",(char *)"arg2", NULL
10621 };
10622
10623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10625 if (!SWIG_IsOK(res1)) {
10626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10627 }
10628 arg1 = reinterpret_cast< wxGrid * >(argp1);
10629 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10630 if (!SWIG_IsOK(res2)) {
10631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10632 }
10633 if (!argp2) {
10634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10635 }
10636 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10637 {
10638 PyThreadState* __tstate = wxPyBeginAllowThreads();
10639 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 {
10644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10645 }
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10653 PyObject *resultobj = 0;
10654 wxGrid *arg1 = (wxGrid *) 0 ;
10655 wxGridTableBase *result = 0 ;
10656 void *argp1 = 0 ;
10657 int res1 = 0 ;
10658 PyObject *swig_obj[1] ;
10659
10660 if (!args) SWIG_fail;
10661 swig_obj[0] = args;
10662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10663 if (!SWIG_IsOK(res1)) {
10664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10665 }
10666 arg1 = reinterpret_cast< wxGrid * >(argp1);
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10675 }
10676 return resultobj;
10677 fail:
10678 return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10683 PyObject *resultobj = 0;
10684 wxGrid *arg1 = (wxGrid *) 0 ;
10685 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10686 bool arg3 = (bool) false ;
10687 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10688 bool result;
10689 void *argp1 = 0 ;
10690 int res1 = 0 ;
10691 int res2 = 0 ;
10692 bool val3 ;
10693 int ecode3 = 0 ;
10694 int val4 ;
10695 int ecode4 = 0 ;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 PyObject * obj3 = 0 ;
10700 char * kwnames[] = {
10701 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10702 };
10703
10704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10708 }
10709 arg1 = reinterpret_cast< wxGrid * >(argp1);
10710 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10711 if (!SWIG_IsOK(res2)) {
10712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10713 }
10714 if (obj2) {
10715 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10716 if (!SWIG_IsOK(ecode3)) {
10717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10718 }
10719 arg3 = static_cast< bool >(val3);
10720 }
10721 if (obj3) {
10722 ecode4 = SWIG_AsVal_int(obj3, &val4);
10723 if (!SWIG_IsOK(ecode4)) {
10724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10725 }
10726 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10727 }
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 {
10735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10736 }
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10744 PyObject *resultobj = 0;
10745 wxGrid *arg1 = (wxGrid *) 0 ;
10746 void *argp1 = 0 ;
10747 int res1 = 0 ;
10748 PyObject *swig_obj[1] ;
10749
10750 if (!args) SWIG_fail;
10751 swig_obj[0] = args;
10752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10753 if (!SWIG_IsOK(res1)) {
10754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10755 }
10756 arg1 = reinterpret_cast< wxGrid * >(argp1);
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->ClearGrid();
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 resultobj = SWIG_Py_Void();
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = 0;
10772 wxGrid *arg1 = (wxGrid *) 0 ;
10773 int arg2 = (int) 0 ;
10774 int arg3 = (int) 1 ;
10775 bool arg4 = (bool) true ;
10776 bool result;
10777 void *argp1 = 0 ;
10778 int res1 = 0 ;
10779 int val2 ;
10780 int ecode2 = 0 ;
10781 int val3 ;
10782 int ecode3 = 0 ;
10783 bool val4 ;
10784 int ecode4 = 0 ;
10785 PyObject * obj0 = 0 ;
10786 PyObject * obj1 = 0 ;
10787 PyObject * obj2 = 0 ;
10788 PyObject * obj3 = 0 ;
10789 char * kwnames[] = {
10790 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10791 };
10792
10793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10795 if (!SWIG_IsOK(res1)) {
10796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10797 }
10798 arg1 = reinterpret_cast< wxGrid * >(argp1);
10799 if (obj1) {
10800 ecode2 = SWIG_AsVal_int(obj1, &val2);
10801 if (!SWIG_IsOK(ecode2)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10803 }
10804 arg2 = static_cast< int >(val2);
10805 }
10806 if (obj2) {
10807 ecode3 = SWIG_AsVal_int(obj2, &val3);
10808 if (!SWIG_IsOK(ecode3)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10810 }
10811 arg3 = static_cast< int >(val3);
10812 }
10813 if (obj3) {
10814 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10815 if (!SWIG_IsOK(ecode4)) {
10816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10817 }
10818 arg4 = static_cast< bool >(val4);
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 {
10827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10828 }
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj = 0;
10837 wxGrid *arg1 = (wxGrid *) 0 ;
10838 int arg2 = (int) 1 ;
10839 bool arg3 = (bool) true ;
10840 bool result;
10841 void *argp1 = 0 ;
10842 int res1 = 0 ;
10843 int val2 ;
10844 int ecode2 = 0 ;
10845 bool val3 ;
10846 int ecode3 = 0 ;
10847 PyObject * obj0 = 0 ;
10848 PyObject * obj1 = 0 ;
10849 PyObject * obj2 = 0 ;
10850 char * kwnames[] = {
10851 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10852 };
10853
10854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10856 if (!SWIG_IsOK(res1)) {
10857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10858 }
10859 arg1 = reinterpret_cast< wxGrid * >(argp1);
10860 if (obj1) {
10861 ecode2 = SWIG_AsVal_int(obj1, &val2);
10862 if (!SWIG_IsOK(ecode2)) {
10863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10864 }
10865 arg2 = static_cast< int >(val2);
10866 }
10867 if (obj2) {
10868 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10869 if (!SWIG_IsOK(ecode3)) {
10870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10871 }
10872 arg3 = static_cast< bool >(val3);
10873 }
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 result = (bool)(arg1)->AppendRows(arg2,arg3);
10877 wxPyEndAllowThreads(__tstate);
10878 if (PyErr_Occurred()) SWIG_fail;
10879 }
10880 {
10881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10882 }
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxGrid *arg1 = (wxGrid *) 0 ;
10892 int arg2 = (int) 0 ;
10893 int arg3 = (int) 1 ;
10894 bool arg4 = (bool) true ;
10895 bool result;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 int val2 ;
10899 int ecode2 = 0 ;
10900 int val3 ;
10901 int ecode3 = 0 ;
10902 bool val4 ;
10903 int ecode4 = 0 ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 PyObject * obj2 = 0 ;
10907 PyObject * obj3 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10916 }
10917 arg1 = reinterpret_cast< wxGrid * >(argp1);
10918 if (obj1) {
10919 ecode2 = SWIG_AsVal_int(obj1, &val2);
10920 if (!SWIG_IsOK(ecode2)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10922 }
10923 arg2 = static_cast< int >(val2);
10924 }
10925 if (obj2) {
10926 ecode3 = SWIG_AsVal_int(obj2, &val3);
10927 if (!SWIG_IsOK(ecode3)) {
10928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10929 }
10930 arg3 = static_cast< int >(val3);
10931 }
10932 if (obj3) {
10933 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10934 if (!SWIG_IsOK(ecode4)) {
10935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10936 }
10937 arg4 = static_cast< bool >(val4);
10938 }
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 {
10946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10947 }
10948 return resultobj;
10949 fail:
10950 return NULL;
10951 }
10952
10953
10954 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj = 0;
10956 wxGrid *arg1 = (wxGrid *) 0 ;
10957 int arg2 = (int) 0 ;
10958 int arg3 = (int) 1 ;
10959 bool arg4 = (bool) true ;
10960 bool result;
10961 void *argp1 = 0 ;
10962 int res1 = 0 ;
10963 int val2 ;
10964 int ecode2 = 0 ;
10965 int val3 ;
10966 int ecode3 = 0 ;
10967 bool val4 ;
10968 int ecode4 = 0 ;
10969 PyObject * obj0 = 0 ;
10970 PyObject * obj1 = 0 ;
10971 PyObject * obj2 = 0 ;
10972 PyObject * obj3 = 0 ;
10973 char * kwnames[] = {
10974 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10975 };
10976
10977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10981 }
10982 arg1 = reinterpret_cast< wxGrid * >(argp1);
10983 if (obj1) {
10984 ecode2 = SWIG_AsVal_int(obj1, &val2);
10985 if (!SWIG_IsOK(ecode2)) {
10986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10987 }
10988 arg2 = static_cast< int >(val2);
10989 }
10990 if (obj2) {
10991 ecode3 = SWIG_AsVal_int(obj2, &val3);
10992 if (!SWIG_IsOK(ecode3)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10994 }
10995 arg3 = static_cast< int >(val3);
10996 }
10997 if (obj3) {
10998 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10999 if (!SWIG_IsOK(ecode4)) {
11000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11001 }
11002 arg4 = static_cast< bool >(val4);
11003 }
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11007 wxPyEndAllowThreads(__tstate);
11008 if (PyErr_Occurred()) SWIG_fail;
11009 }
11010 {
11011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11012 }
11013 return resultobj;
11014 fail:
11015 return NULL;
11016 }
11017
11018
11019 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11020 PyObject *resultobj = 0;
11021 wxGrid *arg1 = (wxGrid *) 0 ;
11022 int arg2 = (int) 1 ;
11023 bool arg3 = (bool) true ;
11024 bool result;
11025 void *argp1 = 0 ;
11026 int res1 = 0 ;
11027 int val2 ;
11028 int ecode2 = 0 ;
11029 bool val3 ;
11030 int ecode3 = 0 ;
11031 PyObject * obj0 = 0 ;
11032 PyObject * obj1 = 0 ;
11033 PyObject * obj2 = 0 ;
11034 char * kwnames[] = {
11035 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11036 };
11037
11038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11040 if (!SWIG_IsOK(res1)) {
11041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11042 }
11043 arg1 = reinterpret_cast< wxGrid * >(argp1);
11044 if (obj1) {
11045 ecode2 = SWIG_AsVal_int(obj1, &val2);
11046 if (!SWIG_IsOK(ecode2)) {
11047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11048 }
11049 arg2 = static_cast< int >(val2);
11050 }
11051 if (obj2) {
11052 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11053 if (!SWIG_IsOK(ecode3)) {
11054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11055 }
11056 arg3 = static_cast< bool >(val3);
11057 }
11058 {
11059 PyThreadState* __tstate = wxPyBeginAllowThreads();
11060 result = (bool)(arg1)->AppendCols(arg2,arg3);
11061 wxPyEndAllowThreads(__tstate);
11062 if (PyErr_Occurred()) SWIG_fail;
11063 }
11064 {
11065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj = 0;
11075 wxGrid *arg1 = (wxGrid *) 0 ;
11076 int arg2 = (int) 0 ;
11077 int arg3 = (int) 1 ;
11078 bool arg4 = (bool) true ;
11079 bool result;
11080 void *argp1 = 0 ;
11081 int res1 = 0 ;
11082 int val2 ;
11083 int ecode2 = 0 ;
11084 int val3 ;
11085 int ecode3 = 0 ;
11086 bool val4 ;
11087 int ecode4 = 0 ;
11088 PyObject * obj0 = 0 ;
11089 PyObject * obj1 = 0 ;
11090 PyObject * obj2 = 0 ;
11091 PyObject * obj3 = 0 ;
11092 char * kwnames[] = {
11093 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11094 };
11095
11096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11098 if (!SWIG_IsOK(res1)) {
11099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11100 }
11101 arg1 = reinterpret_cast< wxGrid * >(argp1);
11102 if (obj1) {
11103 ecode2 = SWIG_AsVal_int(obj1, &val2);
11104 if (!SWIG_IsOK(ecode2)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11106 }
11107 arg2 = static_cast< int >(val2);
11108 }
11109 if (obj2) {
11110 ecode3 = SWIG_AsVal_int(obj2, &val3);
11111 if (!SWIG_IsOK(ecode3)) {
11112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11113 }
11114 arg3 = static_cast< int >(val3);
11115 }
11116 if (obj3) {
11117 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11118 if (!SWIG_IsOK(ecode4)) {
11119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11120 }
11121 arg4 = static_cast< bool >(val4);
11122 }
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj = 0;
11140 wxGrid *arg1 = (wxGrid *) 0 ;
11141 wxDC *arg2 = 0 ;
11142 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 void *argp2 = 0 ;
11146 int res2 = 0 ;
11147 void *argp3 = 0 ;
11148 int res3 = 0 ;
11149 PyObject * obj0 = 0 ;
11150 PyObject * obj1 = 0 ;
11151 PyObject * obj2 = 0 ;
11152 char * kwnames[] = {
11153 (char *) "self",(char *) "dc",(char *) "attr", NULL
11154 };
11155
11156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11158 if (!SWIG_IsOK(res1)) {
11159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11160 }
11161 arg1 = reinterpret_cast< wxGrid * >(argp1);
11162 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11163 if (!SWIG_IsOK(res2)) {
11164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11165 }
11166 if (!argp2) {
11167 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11168 }
11169 arg2 = reinterpret_cast< wxDC * >(argp2);
11170 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11171 if (!SWIG_IsOK(res3)) {
11172 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11173 }
11174 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11175 {
11176 PyThreadState* __tstate = wxPyBeginAllowThreads();
11177 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 resultobj = SWIG_Py_Void();
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj = 0;
11190 wxGrid *arg1 = (wxGrid *) 0 ;
11191 wxDC *arg2 = 0 ;
11192 wxString *arg3 = 0 ;
11193 wxRect *arg4 = 0 ;
11194 int arg5 = (int) wxLEFT ;
11195 int arg6 = (int) wxTOP ;
11196 int arg7 = (int) wxHORIZONTAL ;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 void *argp2 = 0 ;
11200 int res2 = 0 ;
11201 bool temp3 = false ;
11202 wxRect temp4 ;
11203 int val5 ;
11204 int ecode5 = 0 ;
11205 int val6 ;
11206 int ecode6 = 0 ;
11207 int val7 ;
11208 int ecode7 = 0 ;
11209 PyObject * obj0 = 0 ;
11210 PyObject * obj1 = 0 ;
11211 PyObject * obj2 = 0 ;
11212 PyObject * obj3 = 0 ;
11213 PyObject * obj4 = 0 ;
11214 PyObject * obj5 = 0 ;
11215 PyObject * obj6 = 0 ;
11216 char * kwnames[] = {
11217 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11218 };
11219
11220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11224 }
11225 arg1 = reinterpret_cast< wxGrid * >(argp1);
11226 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11227 if (!SWIG_IsOK(res2)) {
11228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11229 }
11230 if (!argp2) {
11231 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11232 }
11233 arg2 = reinterpret_cast< wxDC * >(argp2);
11234 {
11235 arg3 = wxString_in_helper(obj2);
11236 if (arg3 == NULL) SWIG_fail;
11237 temp3 = true;
11238 }
11239 {
11240 arg4 = &temp4;
11241 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11242 }
11243 if (obj4) {
11244 ecode5 = SWIG_AsVal_int(obj4, &val5);
11245 if (!SWIG_IsOK(ecode5)) {
11246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11247 }
11248 arg5 = static_cast< int >(val5);
11249 }
11250 if (obj5) {
11251 ecode6 = SWIG_AsVal_int(obj5, &val6);
11252 if (!SWIG_IsOK(ecode6)) {
11253 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11254 }
11255 arg6 = static_cast< int >(val6);
11256 }
11257 if (obj6) {
11258 ecode7 = SWIG_AsVal_int(obj6, &val7);
11259 if (!SWIG_IsOK(ecode7)) {
11260 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11261 }
11262 arg7 = static_cast< int >(val7);
11263 }
11264 {
11265 PyThreadState* __tstate = wxPyBeginAllowThreads();
11266 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11267 wxPyEndAllowThreads(__tstate);
11268 if (PyErr_Occurred()) SWIG_fail;
11269 }
11270 resultobj = SWIG_Py_Void();
11271 {
11272 if (temp3)
11273 delete arg3;
11274 }
11275 return resultobj;
11276 fail:
11277 {
11278 if (temp3)
11279 delete arg3;
11280 }
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11286 PyObject *resultobj = 0;
11287 wxGrid *arg1 = (wxGrid *) 0 ;
11288 wxDC *arg2 = 0 ;
11289 wxArrayString *arg3 = 0 ;
11290 long *arg4 = (long *) 0 ;
11291 long *arg5 = (long *) 0 ;
11292 void *argp1 = 0 ;
11293 int res1 = 0 ;
11294 void *argp2 = 0 ;
11295 int res2 = 0 ;
11296 bool temp3 = false ;
11297 long temp4 ;
11298 int res4 = SWIG_TMPOBJ ;
11299 long temp5 ;
11300 int res5 = SWIG_TMPOBJ ;
11301 PyObject * obj0 = 0 ;
11302 PyObject * obj1 = 0 ;
11303 PyObject * obj2 = 0 ;
11304 char * kwnames[] = {
11305 (char *) "self",(char *) "dc",(char *) "lines", NULL
11306 };
11307
11308 arg4 = &temp4;
11309 arg5 = &temp5;
11310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11312 if (!SWIG_IsOK(res1)) {
11313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11314 }
11315 arg1 = reinterpret_cast< wxGrid * >(argp1);
11316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11317 if (!SWIG_IsOK(res2)) {
11318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11319 }
11320 if (!argp2) {
11321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11322 }
11323 arg2 = reinterpret_cast< wxDC * >(argp2);
11324 {
11325 if (! PySequence_Check(obj2)) {
11326 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11327 SWIG_fail;
11328 }
11329 arg3 = new wxArrayString;
11330 temp3 = true;
11331 int i, len=PySequence_Length(obj2);
11332 for (i=0; i<len; i++) {
11333 PyObject* item = PySequence_GetItem(obj2, i);
11334 wxString* s = wxString_in_helper(item);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 arg3->Add(*s);
11337 delete s;
11338 Py_DECREF(item);
11339 }
11340 }
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11344 wxPyEndAllowThreads(__tstate);
11345 if (PyErr_Occurred()) SWIG_fail;
11346 }
11347 resultobj = SWIG_Py_Void();
11348 if (SWIG_IsTmpObj(res4)) {
11349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11350 } else {
11351 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11353 }
11354 if (SWIG_IsTmpObj(res5)) {
11355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11356 } else {
11357 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11359 }
11360 {
11361 if (temp3) delete arg3;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp3) delete arg3;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11373 PyObject *resultobj = 0;
11374 wxGrid *arg1 = (wxGrid *) 0 ;
11375 void *argp1 = 0 ;
11376 int res1 = 0 ;
11377 PyObject *swig_obj[1] ;
11378
11379 if (!args) SWIG_fail;
11380 swig_obj[0] = args;
11381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11384 }
11385 arg1 = reinterpret_cast< wxGrid * >(argp1);
11386 {
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 (arg1)->BeginBatch();
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 resultobj = SWIG_Py_Void();
11393 return resultobj;
11394 fail:
11395 return NULL;
11396 }
11397
11398
11399 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11400 PyObject *resultobj = 0;
11401 wxGrid *arg1 = (wxGrid *) 0 ;
11402 void *argp1 = 0 ;
11403 int res1 = 0 ;
11404 PyObject *swig_obj[1] ;
11405
11406 if (!args) SWIG_fail;
11407 swig_obj[0] = args;
11408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11409 if (!SWIG_IsOK(res1)) {
11410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11411 }
11412 arg1 = reinterpret_cast< wxGrid * >(argp1);
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 (arg1)->EndBatch();
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 resultobj = SWIG_Py_Void();
11420 return resultobj;
11421 fail:
11422 return NULL;
11423 }
11424
11425
11426 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11427 PyObject *resultobj = 0;
11428 wxGrid *arg1 = (wxGrid *) 0 ;
11429 int result;
11430 void *argp1 = 0 ;
11431 int res1 = 0 ;
11432 PyObject *swig_obj[1] ;
11433
11434 if (!args) SWIG_fail;
11435 swig_obj[0] = args;
11436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11437 if (!SWIG_IsOK(res1)) {
11438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11439 }
11440 arg1 = reinterpret_cast< wxGrid * >(argp1);
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (int)(arg1)->GetBatchCount();
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_From_int(static_cast< int >(result));
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxGrid *arg1 = (wxGrid *) 0 ;
11457 void *argp1 = 0 ;
11458 int res1 = 0 ;
11459 PyObject *swig_obj[1] ;
11460
11461 if (!args) SWIG_fail;
11462 swig_obj[0] = args;
11463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11466 }
11467 arg1 = reinterpret_cast< wxGrid * >(argp1);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 (arg1)->ForceRefresh();
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 wxGrid *arg1 = (wxGrid *) 0 ;
11484 bool result;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 PyObject *swig_obj[1] ;
11488
11489 if (!args) SWIG_fail;
11490 swig_obj[0] = args;
11491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11492 if (!SWIG_IsOK(res1)) {
11493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11494 }
11495 arg1 = reinterpret_cast< wxGrid * >(argp1);
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (bool)(arg1)->IsEditable();
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11504 }
11505 return resultobj;
11506 fail:
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj = 0;
11513 wxGrid *arg1 = (wxGrid *) 0 ;
11514 bool arg2 ;
11515 void *argp1 = 0 ;
11516 int res1 = 0 ;
11517 bool val2 ;
11518 int ecode2 = 0 ;
11519 PyObject * obj0 = 0 ;
11520 PyObject * obj1 = 0 ;
11521 char * kwnames[] = {
11522 (char *) "self",(char *) "edit", NULL
11523 };
11524
11525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11529 }
11530 arg1 = reinterpret_cast< wxGrid * >(argp1);
11531 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11532 if (!SWIG_IsOK(ecode2)) {
11533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11534 }
11535 arg2 = static_cast< bool >(val2);
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 (arg1)->EnableEditing(arg2);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_Py_Void();
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj = 0;
11551 wxGrid *arg1 = (wxGrid *) 0 ;
11552 bool arg2 = (bool) true ;
11553 void *argp1 = 0 ;
11554 int res1 = 0 ;
11555 bool val2 ;
11556 int ecode2 = 0 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 char * kwnames[] = {
11560 (char *) "self",(char *) "enable", NULL
11561 };
11562
11563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11565 if (!SWIG_IsOK(res1)) {
11566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11567 }
11568 arg1 = reinterpret_cast< wxGrid * >(argp1);
11569 if (obj1) {
11570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11571 if (!SWIG_IsOK(ecode2)) {
11572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11573 }
11574 arg2 = static_cast< bool >(val2);
11575 }
11576 {
11577 PyThreadState* __tstate = wxPyBeginAllowThreads();
11578 (arg1)->EnableCellEditControl(arg2);
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 resultobj = SWIG_Py_Void();
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 PyObject *resultobj = 0;
11591 wxGrid *arg1 = (wxGrid *) 0 ;
11592 void *argp1 = 0 ;
11593 int res1 = 0 ;
11594 PyObject *swig_obj[1] ;
11595
11596 if (!args) SWIG_fail;
11597 swig_obj[0] = args;
11598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11599 if (!SWIG_IsOK(res1)) {
11600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11601 }
11602 arg1 = reinterpret_cast< wxGrid * >(argp1);
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 (arg1)->DisableCellEditControl();
11606 wxPyEndAllowThreads(__tstate);
11607 if (PyErr_Occurred()) SWIG_fail;
11608 }
11609 resultobj = SWIG_Py_Void();
11610 return resultobj;
11611 fail:
11612 return NULL;
11613 }
11614
11615
11616 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11617 PyObject *resultobj = 0;
11618 wxGrid *arg1 = (wxGrid *) 0 ;
11619 bool result;
11620 void *argp1 = 0 ;
11621 int res1 = 0 ;
11622 PyObject *swig_obj[1] ;
11623
11624 if (!args) SWIG_fail;
11625 swig_obj[0] = args;
11626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11627 if (!SWIG_IsOK(res1)) {
11628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11629 }
11630 arg1 = reinterpret_cast< wxGrid * >(argp1);
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 {
11638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11639 }
11640 return resultobj;
11641 fail:
11642 return NULL;
11643 }
11644
11645
11646 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11647 PyObject *resultobj = 0;
11648 wxGrid *arg1 = (wxGrid *) 0 ;
11649 bool result;
11650 void *argp1 = 0 ;
11651 int res1 = 0 ;
11652 PyObject *swig_obj[1] ;
11653
11654 if (!args) SWIG_fail;
11655 swig_obj[0] = args;
11656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11657 if (!SWIG_IsOK(res1)) {
11658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11659 }
11660 arg1 = reinterpret_cast< wxGrid * >(argp1);
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 {
11668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11669 }
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677 PyObject *resultobj = 0;
11678 wxGrid *arg1 = (wxGrid *) 0 ;
11679 bool result;
11680 void *argp1 = 0 ;
11681 int res1 = 0 ;
11682 PyObject *swig_obj[1] ;
11683
11684 if (!args) SWIG_fail;
11685 swig_obj[0] = args;
11686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11687 if (!SWIG_IsOK(res1)) {
11688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11689 }
11690 arg1 = reinterpret_cast< wxGrid * >(argp1);
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11699 }
11700 return resultobj;
11701 fail:
11702 return NULL;
11703 }
11704
11705
11706 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11707 PyObject *resultobj = 0;
11708 wxGrid *arg1 = (wxGrid *) 0 ;
11709 bool result;
11710 void *argp1 = 0 ;
11711 int res1 = 0 ;
11712 PyObject *swig_obj[1] ;
11713
11714 if (!args) SWIG_fail;
11715 swig_obj[0] = args;
11716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11717 if (!SWIG_IsOK(res1)) {
11718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11719 }
11720 arg1 = reinterpret_cast< wxGrid * >(argp1);
11721 {
11722 PyThreadState* __tstate = wxPyBeginAllowThreads();
11723 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 {
11728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11729 }
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxGrid *arg1 = (wxGrid *) 0 ;
11739 void *argp1 = 0 ;
11740 int res1 = 0 ;
11741 PyObject *swig_obj[1] ;
11742
11743 if (!args) SWIG_fail;
11744 swig_obj[0] = args;
11745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11746 if (!SWIG_IsOK(res1)) {
11747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11748 }
11749 arg1 = reinterpret_cast< wxGrid * >(argp1);
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 (arg1)->ShowCellEditControl();
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 resultobj = SWIG_Py_Void();
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *resultobj = 0;
11765 wxGrid *arg1 = (wxGrid *) 0 ;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11775 }
11776 arg1 = reinterpret_cast< wxGrid * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 (arg1)->HideCellEditControl();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_Py_Void();
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxGrid *arg1 = (wxGrid *) 0 ;
11793 void *argp1 = 0 ;
11794 int res1 = 0 ;
11795 PyObject *swig_obj[1] ;
11796
11797 if (!args) SWIG_fail;
11798 swig_obj[0] = args;
11799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11800 if (!SWIG_IsOK(res1)) {
11801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11802 }
11803 arg1 = reinterpret_cast< wxGrid * >(argp1);
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 (arg1)->SaveEditControlValue();
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 resultobj = SWIG_Py_Void();
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj = 0;
11819 wxGrid *arg1 = (wxGrid *) 0 ;
11820 int arg2 ;
11821 int arg3 ;
11822 wxGridCellCoords result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 int val2 ;
11826 int ecode2 = 0 ;
11827 int val3 ;
11828 int ecode3 = 0 ;
11829 PyObject * obj0 = 0 ;
11830 PyObject * obj1 = 0 ;
11831 PyObject * obj2 = 0 ;
11832 char * kwnames[] = {
11833 (char *) "self",(char *) "x",(char *) "y", NULL
11834 };
11835
11836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11838 if (!SWIG_IsOK(res1)) {
11839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11840 }
11841 arg1 = reinterpret_cast< wxGrid * >(argp1);
11842 ecode2 = SWIG_AsVal_int(obj1, &val2);
11843 if (!SWIG_IsOK(ecode2)) {
11844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11845 }
11846 arg2 = static_cast< int >(val2);
11847 ecode3 = SWIG_AsVal_int(obj2, &val3);
11848 if (!SWIG_IsOK(ecode3)) {
11849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11850 }
11851 arg3 = static_cast< int >(val3);
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 result = wxGrid_XYToCell(arg1,arg2,arg3);
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11866 PyObject *resultobj = 0;
11867 wxGrid *arg1 = (wxGrid *) 0 ;
11868 int arg2 ;
11869 int result;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 int val2 ;
11873 int ecode2 = 0 ;
11874 PyObject * obj0 = 0 ;
11875 PyObject * obj1 = 0 ;
11876 char * kwnames[] = {
11877 (char *) "self",(char *) "y", NULL
11878 };
11879
11880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11882 if (!SWIG_IsOK(res1)) {
11883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11884 }
11885 arg1 = reinterpret_cast< wxGrid * >(argp1);
11886 ecode2 = SWIG_AsVal_int(obj1, &val2);
11887 if (!SWIG_IsOK(ecode2)) {
11888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11889 }
11890 arg2 = static_cast< int >(val2);
11891 {
11892 PyThreadState* __tstate = wxPyBeginAllowThreads();
11893 result = (int)(arg1)->YToRow(arg2);
11894 wxPyEndAllowThreads(__tstate);
11895 if (PyErr_Occurred()) SWIG_fail;
11896 }
11897 resultobj = SWIG_From_int(static_cast< int >(result));
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj = 0;
11906 wxGrid *arg1 = (wxGrid *) 0 ;
11907 int arg2 ;
11908 bool arg3 = (bool) false ;
11909 int result;
11910 void *argp1 = 0 ;
11911 int res1 = 0 ;
11912 int val2 ;
11913 int ecode2 = 0 ;
11914 bool val3 ;
11915 int ecode3 = 0 ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 PyObject * obj2 = 0 ;
11919 char * kwnames[] = {
11920 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11921 };
11922
11923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11925 if (!SWIG_IsOK(res1)) {
11926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11927 }
11928 arg1 = reinterpret_cast< wxGrid * >(argp1);
11929 ecode2 = SWIG_AsVal_int(obj1, &val2);
11930 if (!SWIG_IsOK(ecode2)) {
11931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11932 }
11933 arg2 = static_cast< int >(val2);
11934 if (obj2) {
11935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11936 if (!SWIG_IsOK(ecode3)) {
11937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11938 }
11939 arg3 = static_cast< bool >(val3);
11940 }
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (int)(arg1)->XToCol(arg2,arg3);
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 resultobj = SWIG_From_int(static_cast< int >(result));
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj = 0;
11956 wxGrid *arg1 = (wxGrid *) 0 ;
11957 int arg2 ;
11958 int result;
11959 void *argp1 = 0 ;
11960 int res1 = 0 ;
11961 int val2 ;
11962 int ecode2 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "y", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11973 }
11974 arg1 = reinterpret_cast< wxGrid * >(argp1);
11975 ecode2 = SWIG_AsVal_int(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11978 }
11979 arg2 = static_cast< int >(val2);
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 result = (int)(arg1)->YToEdgeOfRow(arg2);
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 resultobj = SWIG_From_int(static_cast< int >(result));
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj = 0;
11995 wxGrid *arg1 = (wxGrid *) 0 ;
11996 int arg2 ;
11997 int result;
11998 void *argp1 = 0 ;
11999 int res1 = 0 ;
12000 int val2 ;
12001 int ecode2 = 0 ;
12002 PyObject * obj0 = 0 ;
12003 PyObject * obj1 = 0 ;
12004 char * kwnames[] = {
12005 (char *) "self",(char *) "x", NULL
12006 };
12007
12008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12010 if (!SWIG_IsOK(res1)) {
12011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12012 }
12013 arg1 = reinterpret_cast< wxGrid * >(argp1);
12014 ecode2 = SWIG_AsVal_int(obj1, &val2);
12015 if (!SWIG_IsOK(ecode2)) {
12016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12017 }
12018 arg2 = static_cast< int >(val2);
12019 {
12020 PyThreadState* __tstate = wxPyBeginAllowThreads();
12021 result = (int)(arg1)->XToEdgeOfCol(arg2);
12022 wxPyEndAllowThreads(__tstate);
12023 if (PyErr_Occurred()) SWIG_fail;
12024 }
12025 resultobj = SWIG_From_int(static_cast< int >(result));
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj = 0;
12034 wxGrid *arg1 = (wxGrid *) 0 ;
12035 int arg2 ;
12036 int arg3 ;
12037 wxRect result;
12038 void *argp1 = 0 ;
12039 int res1 = 0 ;
12040 int val2 ;
12041 int ecode2 = 0 ;
12042 int val3 ;
12043 int ecode3 = 0 ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 PyObject * obj2 = 0 ;
12047 char * kwnames[] = {
12048 (char *) "self",(char *) "row",(char *) "col", NULL
12049 };
12050
12051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12053 if (!SWIG_IsOK(res1)) {
12054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12055 }
12056 arg1 = reinterpret_cast< wxGrid * >(argp1);
12057 ecode2 = SWIG_AsVal_int(obj1, &val2);
12058 if (!SWIG_IsOK(ecode2)) {
12059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12060 }
12061 arg2 = static_cast< int >(val2);
12062 ecode3 = SWIG_AsVal_int(obj2, &val3);
12063 if (!SWIG_IsOK(ecode3)) {
12064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12065 }
12066 arg3 = static_cast< int >(val3);
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (arg1)->CellToRect(arg2,arg3);
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12074 return resultobj;
12075 fail:
12076 return NULL;
12077 }
12078
12079
12080 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12081 PyObject *resultobj = 0;
12082 wxGrid *arg1 = (wxGrid *) 0 ;
12083 int result;
12084 void *argp1 = 0 ;
12085 int res1 = 0 ;
12086 PyObject *swig_obj[1] ;
12087
12088 if (!args) SWIG_fail;
12089 swig_obj[0] = args;
12090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12091 if (!SWIG_IsOK(res1)) {
12092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12093 }
12094 arg1 = reinterpret_cast< wxGrid * >(argp1);
12095 {
12096 PyThreadState* __tstate = wxPyBeginAllowThreads();
12097 result = (int)(arg1)->GetGridCursorRow();
12098 wxPyEndAllowThreads(__tstate);
12099 if (PyErr_Occurred()) SWIG_fail;
12100 }
12101 resultobj = SWIG_From_int(static_cast< int >(result));
12102 return resultobj;
12103 fail:
12104 return NULL;
12105 }
12106
12107
12108 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12109 PyObject *resultobj = 0;
12110 wxGrid *arg1 = (wxGrid *) 0 ;
12111 int result;
12112 void *argp1 = 0 ;
12113 int res1 = 0 ;
12114 PyObject *swig_obj[1] ;
12115
12116 if (!args) SWIG_fail;
12117 swig_obj[0] = args;
12118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12119 if (!SWIG_IsOK(res1)) {
12120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12121 }
12122 arg1 = reinterpret_cast< wxGrid * >(argp1);
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 result = (int)(arg1)->GetGridCursorCol();
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 resultobj = SWIG_From_int(static_cast< int >(result));
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12137 PyObject *resultobj = 0;
12138 wxGrid *arg1 = (wxGrid *) 0 ;
12139 int arg2 ;
12140 int arg3 ;
12141 bool arg4 = (bool) true ;
12142 bool result;
12143 void *argp1 = 0 ;
12144 int res1 = 0 ;
12145 int val2 ;
12146 int ecode2 = 0 ;
12147 int val3 ;
12148 int ecode3 = 0 ;
12149 bool val4 ;
12150 int ecode4 = 0 ;
12151 PyObject * obj0 = 0 ;
12152 PyObject * obj1 = 0 ;
12153 PyObject * obj2 = 0 ;
12154 PyObject * obj3 = 0 ;
12155 char * kwnames[] = {
12156 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12157 };
12158
12159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12161 if (!SWIG_IsOK(res1)) {
12162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12163 }
12164 arg1 = reinterpret_cast< wxGrid * >(argp1);
12165 ecode2 = SWIG_AsVal_int(obj1, &val2);
12166 if (!SWIG_IsOK(ecode2)) {
12167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12168 }
12169 arg2 = static_cast< int >(val2);
12170 ecode3 = SWIG_AsVal_int(obj2, &val3);
12171 if (!SWIG_IsOK(ecode3)) {
12172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12173 }
12174 arg3 = static_cast< int >(val3);
12175 if (obj3) {
12176 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12177 if (!SWIG_IsOK(ecode4)) {
12178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12179 }
12180 arg4 = static_cast< bool >(val4);
12181 }
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 {
12189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12190 }
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj = 0;
12199 wxGrid *arg1 = (wxGrid *) 0 ;
12200 int arg2 ;
12201 int arg3 ;
12202 void *argp1 = 0 ;
12203 int res1 = 0 ;
12204 int val2 ;
12205 int ecode2 = 0 ;
12206 int val3 ;
12207 int ecode3 = 0 ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 PyObject * obj2 = 0 ;
12211 char * kwnames[] = {
12212 (char *) "self",(char *) "row",(char *) "col", NULL
12213 };
12214
12215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12217 if (!SWIG_IsOK(res1)) {
12218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12219 }
12220 arg1 = reinterpret_cast< wxGrid * >(argp1);
12221 ecode2 = SWIG_AsVal_int(obj1, &val2);
12222 if (!SWIG_IsOK(ecode2)) {
12223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12224 }
12225 arg2 = static_cast< int >(val2);
12226 ecode3 = SWIG_AsVal_int(obj2, &val3);
12227 if (!SWIG_IsOK(ecode3)) {
12228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12229 }
12230 arg3 = static_cast< int >(val3);
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 (arg1)->MakeCellVisible(arg2,arg3);
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 resultobj = SWIG_Py_Void();
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj = 0;
12246 wxGrid *arg1 = (wxGrid *) 0 ;
12247 int arg2 ;
12248 int arg3 ;
12249 void *argp1 = 0 ;
12250 int res1 = 0 ;
12251 int val2 ;
12252 int ecode2 = 0 ;
12253 int val3 ;
12254 int ecode3 = 0 ;
12255 PyObject * obj0 = 0 ;
12256 PyObject * obj1 = 0 ;
12257 PyObject * obj2 = 0 ;
12258 char * kwnames[] = {
12259 (char *) "self",(char *) "row",(char *) "col", NULL
12260 };
12261
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12264 if (!SWIG_IsOK(res1)) {
12265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12266 }
12267 arg1 = reinterpret_cast< wxGrid * >(argp1);
12268 ecode2 = SWIG_AsVal_int(obj1, &val2);
12269 if (!SWIG_IsOK(ecode2)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12271 }
12272 arg2 = static_cast< int >(val2);
12273 ecode3 = SWIG_AsVal_int(obj2, &val3);
12274 if (!SWIG_IsOK(ecode3)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12276 }
12277 arg3 = static_cast< int >(val3);
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 (arg1)->SetGridCursor(arg2,arg3);
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 resultobj = SWIG_Py_Void();
12285 return resultobj;
12286 fail:
12287 return NULL;
12288 }
12289
12290
12291 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12292 PyObject *resultobj = 0;
12293 wxGrid *arg1 = (wxGrid *) 0 ;
12294 bool arg2 ;
12295 bool result;
12296 void *argp1 = 0 ;
12297 int res1 = 0 ;
12298 bool val2 ;
12299 int ecode2 = 0 ;
12300 PyObject * obj0 = 0 ;
12301 PyObject * obj1 = 0 ;
12302 char * kwnames[] = {
12303 (char *) "self",(char *) "expandSelection", NULL
12304 };
12305
12306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12308 if (!SWIG_IsOK(res1)) {
12309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12310 }
12311 arg1 = reinterpret_cast< wxGrid * >(argp1);
12312 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12313 if (!SWIG_IsOK(ecode2)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12315 }
12316 arg2 = static_cast< bool >(val2);
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 result = (bool)(arg1)->MoveCursorUp(arg2);
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 {
12324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12325 }
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj = 0;
12334 wxGrid *arg1 = (wxGrid *) 0 ;
12335 bool arg2 ;
12336 bool result;
12337 void *argp1 = 0 ;
12338 int res1 = 0 ;
12339 bool val2 ;
12340 int ecode2 = 0 ;
12341 PyObject * obj0 = 0 ;
12342 PyObject * obj1 = 0 ;
12343 char * kwnames[] = {
12344 (char *) "self",(char *) "expandSelection", NULL
12345 };
12346
12347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12349 if (!SWIG_IsOK(res1)) {
12350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12351 }
12352 arg1 = reinterpret_cast< wxGrid * >(argp1);
12353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12354 if (!SWIG_IsOK(ecode2)) {
12355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12356 }
12357 arg2 = static_cast< bool >(val2);
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (bool)(arg1)->MoveCursorDown(arg2);
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 {
12365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj = 0;
12375 wxGrid *arg1 = (wxGrid *) 0 ;
12376 bool arg2 ;
12377 bool result;
12378 void *argp1 = 0 ;
12379 int res1 = 0 ;
12380 bool val2 ;
12381 int ecode2 = 0 ;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 char * kwnames[] = {
12385 (char *) "self",(char *) "expandSelection", NULL
12386 };
12387
12388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12390 if (!SWIG_IsOK(res1)) {
12391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12392 }
12393 arg1 = reinterpret_cast< wxGrid * >(argp1);
12394 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12395 if (!SWIG_IsOK(ecode2)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12397 }
12398 arg2 = static_cast< bool >(val2);
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (bool)(arg1)->MoveCursorLeft(arg2);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxGrid *arg1 = (wxGrid *) 0 ;
12417 bool arg2 ;
12418 bool result;
12419 void *argp1 = 0 ;
12420 int res1 = 0 ;
12421 bool val2 ;
12422 int ecode2 = 0 ;
12423 PyObject * obj0 = 0 ;
12424 PyObject * obj1 = 0 ;
12425 char * kwnames[] = {
12426 (char *) "self",(char *) "expandSelection", NULL
12427 };
12428
12429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12431 if (!SWIG_IsOK(res1)) {
12432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12433 }
12434 arg1 = reinterpret_cast< wxGrid * >(argp1);
12435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12436 if (!SWIG_IsOK(ecode2)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12438 }
12439 arg2 = static_cast< bool >(val2);
12440 {
12441 PyThreadState* __tstate = wxPyBeginAllowThreads();
12442 result = (bool)(arg1)->MoveCursorRight(arg2);
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 {
12447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12456 PyObject *resultobj = 0;
12457 wxGrid *arg1 = (wxGrid *) 0 ;
12458 bool result;
12459 void *argp1 = 0 ;
12460 int res1 = 0 ;
12461 PyObject *swig_obj[1] ;
12462
12463 if (!args) SWIG_fail;
12464 swig_obj[0] = args;
12465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12466 if (!SWIG_IsOK(res1)) {
12467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12468 }
12469 arg1 = reinterpret_cast< wxGrid * >(argp1);
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (bool)(arg1)->MovePageDown();
12473 wxPyEndAllowThreads(__tstate);
12474 if (PyErr_Occurred()) SWIG_fail;
12475 }
12476 {
12477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12478 }
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12486 PyObject *resultobj = 0;
12487 wxGrid *arg1 = (wxGrid *) 0 ;
12488 bool result;
12489 void *argp1 = 0 ;
12490 int res1 = 0 ;
12491 PyObject *swig_obj[1] ;
12492
12493 if (!args) SWIG_fail;
12494 swig_obj[0] = args;
12495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12496 if (!SWIG_IsOK(res1)) {
12497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12498 }
12499 arg1 = reinterpret_cast< wxGrid * >(argp1);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (bool)(arg1)->MovePageUp();
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 {
12507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12508 }
12509 return resultobj;
12510 fail:
12511 return NULL;
12512 }
12513
12514
12515 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12516 PyObject *resultobj = 0;
12517 wxGrid *arg1 = (wxGrid *) 0 ;
12518 bool arg2 ;
12519 bool result;
12520 void *argp1 = 0 ;
12521 int res1 = 0 ;
12522 bool val2 ;
12523 int ecode2 = 0 ;
12524 PyObject * obj0 = 0 ;
12525 PyObject * obj1 = 0 ;
12526 char * kwnames[] = {
12527 (char *) "self",(char *) "expandSelection", NULL
12528 };
12529
12530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12532 if (!SWIG_IsOK(res1)) {
12533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12534 }
12535 arg1 = reinterpret_cast< wxGrid * >(argp1);
12536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12537 if (!SWIG_IsOK(ecode2)) {
12538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12539 }
12540 arg2 = static_cast< bool >(val2);
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 {
12548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12549 }
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj = 0;
12558 wxGrid *arg1 = (wxGrid *) 0 ;
12559 bool arg2 ;
12560 bool result;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 bool val2 ;
12564 int ecode2 = 0 ;
12565 PyObject * obj0 = 0 ;
12566 PyObject * obj1 = 0 ;
12567 char * kwnames[] = {
12568 (char *) "self",(char *) "expandSelection", NULL
12569 };
12570
12571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12573 if (!SWIG_IsOK(res1)) {
12574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12575 }
12576 arg1 = reinterpret_cast< wxGrid * >(argp1);
12577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12578 if (!SWIG_IsOK(ecode2)) {
12579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12580 }
12581 arg2 = static_cast< bool >(val2);
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 {
12589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12590 }
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12598 PyObject *resultobj = 0;
12599 wxGrid *arg1 = (wxGrid *) 0 ;
12600 bool arg2 ;
12601 bool result;
12602 void *argp1 = 0 ;
12603 int res1 = 0 ;
12604 bool val2 ;
12605 int ecode2 = 0 ;
12606 PyObject * obj0 = 0 ;
12607 PyObject * obj1 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "self",(char *) "expandSelection", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12616 }
12617 arg1 = reinterpret_cast< wxGrid * >(argp1);
12618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12619 if (!SWIG_IsOK(ecode2)) {
12620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12621 }
12622 arg2 = static_cast< bool >(val2);
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 {
12630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12631 }
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 wxGrid *arg1 = (wxGrid *) 0 ;
12641 bool arg2 ;
12642 bool result;
12643 void *argp1 = 0 ;
12644 int res1 = 0 ;
12645 bool val2 ;
12646 int ecode2 = 0 ;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "self",(char *) "expandSelection", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12655 if (!SWIG_IsOK(res1)) {
12656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12657 }
12658 arg1 = reinterpret_cast< wxGrid * >(argp1);
12659 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12660 if (!SWIG_IsOK(ecode2)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12662 }
12663 arg2 = static_cast< bool >(val2);
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12672 }
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *resultobj = 0;
12681 wxGrid *arg1 = (wxGrid *) 0 ;
12682 int result;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 PyObject *swig_obj[1] ;
12686
12687 if (!args) SWIG_fail;
12688 swig_obj[0] = args;
12689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12690 if (!SWIG_IsOK(res1)) {
12691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12692 }
12693 arg1 = reinterpret_cast< wxGrid * >(argp1);
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = (int)(arg1)->GetDefaultRowLabelSize();
12697 wxPyEndAllowThreads(__tstate);
12698 if (PyErr_Occurred()) SWIG_fail;
12699 }
12700 resultobj = SWIG_From_int(static_cast< int >(result));
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *resultobj = 0;
12709 wxGrid *arg1 = (wxGrid *) 0 ;
12710 int result;
12711 void *argp1 = 0 ;
12712 int res1 = 0 ;
12713 PyObject *swig_obj[1] ;
12714
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12720 }
12721 arg1 = reinterpret_cast< wxGrid * >(argp1);
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (int)(arg1)->GetRowLabelSize();
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 resultobj = SWIG_From_int(static_cast< int >(result));
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12736 PyObject *resultobj = 0;
12737 wxGrid *arg1 = (wxGrid *) 0 ;
12738 int result;
12739 void *argp1 = 0 ;
12740 int res1 = 0 ;
12741 PyObject *swig_obj[1] ;
12742
12743 if (!args) SWIG_fail;
12744 swig_obj[0] = args;
12745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12748 }
12749 arg1 = reinterpret_cast< wxGrid * >(argp1);
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (int)(arg1)->GetDefaultColLabelSize();
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 resultobj = SWIG_From_int(static_cast< int >(result));
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 wxGrid *arg1 = (wxGrid *) 0 ;
12766 int result;
12767 void *argp1 = 0 ;
12768 int res1 = 0 ;
12769 PyObject *swig_obj[1] ;
12770
12771 if (!args) SWIG_fail;
12772 swig_obj[0] = args;
12773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12774 if (!SWIG_IsOK(res1)) {
12775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12776 }
12777 arg1 = reinterpret_cast< wxGrid * >(argp1);
12778 {
12779 PyThreadState* __tstate = wxPyBeginAllowThreads();
12780 result = (int)(arg1)->GetColLabelSize();
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 resultobj = SWIG_From_int(static_cast< int >(result));
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792 PyObject *resultobj = 0;
12793 wxGrid *arg1 = (wxGrid *) 0 ;
12794 wxColour result;
12795 void *argp1 = 0 ;
12796 int res1 = 0 ;
12797 PyObject *swig_obj[1] ;
12798
12799 if (!args) SWIG_fail;
12800 swig_obj[0] = args;
12801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12804 }
12805 arg1 = reinterpret_cast< wxGrid * >(argp1);
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (arg1)->GetLabelBackgroundColour();
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *resultobj = 0;
12821 wxGrid *arg1 = (wxGrid *) 0 ;
12822 wxColour result;
12823 void *argp1 = 0 ;
12824 int res1 = 0 ;
12825 PyObject *swig_obj[1] ;
12826
12827 if (!args) SWIG_fail;
12828 swig_obj[0] = args;
12829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12830 if (!SWIG_IsOK(res1)) {
12831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12832 }
12833 arg1 = reinterpret_cast< wxGrid * >(argp1);
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 result = (arg1)->GetLabelTextColour();
12837 wxPyEndAllowThreads(__tstate);
12838 if (PyErr_Occurred()) SWIG_fail;
12839 }
12840 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 PyObject *resultobj = 0;
12849 wxGrid *arg1 = (wxGrid *) 0 ;
12850 wxFont result;
12851 void *argp1 = 0 ;
12852 int res1 = 0 ;
12853 PyObject *swig_obj[1] ;
12854
12855 if (!args) SWIG_fail;
12856 swig_obj[0] = args;
12857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12858 if (!SWIG_IsOK(res1)) {
12859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12860 }
12861 arg1 = reinterpret_cast< wxGrid * >(argp1);
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (arg1)->GetLabelFont();
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12876 PyObject *resultobj = 0;
12877 wxGrid *arg1 = (wxGrid *) 0 ;
12878 int *arg2 = (int *) 0 ;
12879 int *arg3 = (int *) 0 ;
12880 void *argp1 = 0 ;
12881 int res1 = 0 ;
12882 int temp2 ;
12883 int res2 = SWIG_TMPOBJ ;
12884 int temp3 ;
12885 int res3 = SWIG_TMPOBJ ;
12886 PyObject *swig_obj[1] ;
12887
12888 arg2 = &temp2;
12889 arg3 = &temp3;
12890 if (!args) SWIG_fail;
12891 swig_obj[0] = args;
12892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12893 if (!SWIG_IsOK(res1)) {
12894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12895 }
12896 arg1 = reinterpret_cast< wxGrid * >(argp1);
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 (arg1)->GetRowLabelAlignment(arg2,arg3);
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 resultobj = SWIG_Py_Void();
12904 if (SWIG_IsTmpObj(res2)) {
12905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12906 } else {
12907 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12909 }
12910 if (SWIG_IsTmpObj(res3)) {
12911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12912 } else {
12913 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12915 }
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxGrid *arg1 = (wxGrid *) 0 ;
12925 int *arg2 = (int *) 0 ;
12926 int *arg3 = (int *) 0 ;
12927 void *argp1 = 0 ;
12928 int res1 = 0 ;
12929 int temp2 ;
12930 int res2 = SWIG_TMPOBJ ;
12931 int temp3 ;
12932 int res3 = SWIG_TMPOBJ ;
12933 PyObject *swig_obj[1] ;
12934
12935 arg2 = &temp2;
12936 arg3 = &temp3;
12937 if (!args) SWIG_fail;
12938 swig_obj[0] = args;
12939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12940 if (!SWIG_IsOK(res1)) {
12941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12942 }
12943 arg1 = reinterpret_cast< wxGrid * >(argp1);
12944 {
12945 PyThreadState* __tstate = wxPyBeginAllowThreads();
12946 (arg1)->GetColLabelAlignment(arg2,arg3);
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 resultobj = SWIG_Py_Void();
12951 if (SWIG_IsTmpObj(res2)) {
12952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12953 } else {
12954 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12956 }
12957 if (SWIG_IsTmpObj(res3)) {
12958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12959 } else {
12960 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12962 }
12963 return resultobj;
12964 fail:
12965 return NULL;
12966 }
12967
12968
12969 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12970 PyObject *resultobj = 0;
12971 wxGrid *arg1 = (wxGrid *) 0 ;
12972 int result;
12973 void *argp1 = 0 ;
12974 int res1 = 0 ;
12975 PyObject *swig_obj[1] ;
12976
12977 if (!args) SWIG_fail;
12978 swig_obj[0] = args;
12979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12980 if (!SWIG_IsOK(res1)) {
12981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12982 }
12983 arg1 = reinterpret_cast< wxGrid * >(argp1);
12984 {
12985 PyThreadState* __tstate = wxPyBeginAllowThreads();
12986 result = (int)(arg1)->GetColLabelTextOrientation();
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 resultobj = SWIG_From_int(static_cast< int >(result));
12991 return resultobj;
12992 fail:
12993 return NULL;
12994 }
12995
12996
12997 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12998 PyObject *resultobj = 0;
12999 wxGrid *arg1 = (wxGrid *) 0 ;
13000 int arg2 ;
13001 wxString result;
13002 void *argp1 = 0 ;
13003 int res1 = 0 ;
13004 int val2 ;
13005 int ecode2 = 0 ;
13006 PyObject * obj0 = 0 ;
13007 PyObject * obj1 = 0 ;
13008 char * kwnames[] = {
13009 (char *) "self",(char *) "row", NULL
13010 };
13011
13012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13014 if (!SWIG_IsOK(res1)) {
13015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13016 }
13017 arg1 = reinterpret_cast< wxGrid * >(argp1);
13018 ecode2 = SWIG_AsVal_int(obj1, &val2);
13019 if (!SWIG_IsOK(ecode2)) {
13020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13021 }
13022 arg2 = static_cast< int >(val2);
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 result = (arg1)->GetRowLabelValue(arg2);
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 {
13030 #if wxUSE_UNICODE
13031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13032 #else
13033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13034 #endif
13035 }
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj = 0;
13044 wxGrid *arg1 = (wxGrid *) 0 ;
13045 int arg2 ;
13046 wxString result;
13047 void *argp1 = 0 ;
13048 int res1 = 0 ;
13049 int val2 ;
13050 int ecode2 = 0 ;
13051 PyObject * obj0 = 0 ;
13052 PyObject * obj1 = 0 ;
13053 char * kwnames[] = {
13054 (char *) "self",(char *) "col", NULL
13055 };
13056
13057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13059 if (!SWIG_IsOK(res1)) {
13060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13061 }
13062 arg1 = reinterpret_cast< wxGrid * >(argp1);
13063 ecode2 = SWIG_AsVal_int(obj1, &val2);
13064 if (!SWIG_IsOK(ecode2)) {
13065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13066 }
13067 arg2 = static_cast< int >(val2);
13068 {
13069 PyThreadState* __tstate = wxPyBeginAllowThreads();
13070 result = (arg1)->GetColLabelValue(arg2);
13071 wxPyEndAllowThreads(__tstate);
13072 if (PyErr_Occurred()) SWIG_fail;
13073 }
13074 {
13075 #if wxUSE_UNICODE
13076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13077 #else
13078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13079 #endif
13080 }
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13088 PyObject *resultobj = 0;
13089 wxGrid *arg1 = (wxGrid *) 0 ;
13090 wxColour result;
13091 void *argp1 = 0 ;
13092 int res1 = 0 ;
13093 PyObject *swig_obj[1] ;
13094
13095 if (!args) SWIG_fail;
13096 swig_obj[0] = args;
13097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13098 if (!SWIG_IsOK(res1)) {
13099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13100 }
13101 arg1 = reinterpret_cast< wxGrid * >(argp1);
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (arg1)->GetGridLineColour();
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13116 PyObject *resultobj = 0;
13117 wxGrid *arg1 = (wxGrid *) 0 ;
13118 wxPen result;
13119 void *argp1 = 0 ;
13120 int res1 = 0 ;
13121 PyObject *swig_obj[1] ;
13122
13123 if (!args) SWIG_fail;
13124 swig_obj[0] = args;
13125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13126 if (!SWIG_IsOK(res1)) {
13127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13128 }
13129 arg1 = reinterpret_cast< wxGrid * >(argp1);
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 result = (arg1)->GetDefaultGridLinePen();
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 wxGrid *arg1 = (wxGrid *) 0 ;
13146 int arg2 ;
13147 wxPen result;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 int val2 ;
13151 int ecode2 = 0 ;
13152 PyObject * obj0 = 0 ;
13153 PyObject * obj1 = 0 ;
13154 char * kwnames[] = {
13155 (char *) "self",(char *) "row", NULL
13156 };
13157
13158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13162 }
13163 arg1 = reinterpret_cast< wxGrid * >(argp1);
13164 ecode2 = SWIG_AsVal_int(obj1, &val2);
13165 if (!SWIG_IsOK(ecode2)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13167 }
13168 arg2 = static_cast< int >(val2);
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (arg1)->GetRowGridLinePen(arg2);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 wxGrid *arg1 = (wxGrid *) 0 ;
13185 int arg2 ;
13186 wxPen result;
13187 void *argp1 = 0 ;
13188 int res1 = 0 ;
13189 int val2 ;
13190 int ecode2 = 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 char * kwnames[] = {
13194 (char *) "self",(char *) "col", NULL
13195 };
13196
13197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13199 if (!SWIG_IsOK(res1)) {
13200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13201 }
13202 arg1 = reinterpret_cast< wxGrid * >(argp1);
13203 ecode2 = SWIG_AsVal_int(obj1, &val2);
13204 if (!SWIG_IsOK(ecode2)) {
13205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13206 }
13207 arg2 = static_cast< int >(val2);
13208 {
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 result = (arg1)->GetColGridLinePen(arg2);
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13215 return resultobj;
13216 fail:
13217 return NULL;
13218 }
13219
13220
13221 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13222 PyObject *resultobj = 0;
13223 wxGrid *arg1 = (wxGrid *) 0 ;
13224 wxColour result;
13225 void *argp1 = 0 ;
13226 int res1 = 0 ;
13227 PyObject *swig_obj[1] ;
13228
13229 if (!args) SWIG_fail;
13230 swig_obj[0] = args;
13231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13232 if (!SWIG_IsOK(res1)) {
13233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13234 }
13235 arg1 = reinterpret_cast< wxGrid * >(argp1);
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 result = (arg1)->GetCellHighlightColour();
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13250 PyObject *resultobj = 0;
13251 wxGrid *arg1 = (wxGrid *) 0 ;
13252 int result;
13253 void *argp1 = 0 ;
13254 int res1 = 0 ;
13255 PyObject *swig_obj[1] ;
13256
13257 if (!args) SWIG_fail;
13258 swig_obj[0] = args;
13259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13260 if (!SWIG_IsOK(res1)) {
13261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13262 }
13263 arg1 = reinterpret_cast< wxGrid * >(argp1);
13264 {
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (int)(arg1)->GetCellHighlightPenWidth();
13267 wxPyEndAllowThreads(__tstate);
13268 if (PyErr_Occurred()) SWIG_fail;
13269 }
13270 resultobj = SWIG_From_int(static_cast< int >(result));
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13278 PyObject *resultobj = 0;
13279 wxGrid *arg1 = (wxGrid *) 0 ;
13280 int result;
13281 void *argp1 = 0 ;
13282 int res1 = 0 ;
13283 PyObject *swig_obj[1] ;
13284
13285 if (!args) SWIG_fail;
13286 swig_obj[0] = args;
13287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13290 }
13291 arg1 = reinterpret_cast< wxGrid * >(argp1);
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (int)(arg1)->GetCellHighlightROPenWidth();
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_From_int(static_cast< int >(result));
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj = 0;
13307 wxGrid *arg1 = (wxGrid *) 0 ;
13308 int arg2 ;
13309 void *argp1 = 0 ;
13310 int res1 = 0 ;
13311 int val2 ;
13312 int ecode2 = 0 ;
13313 PyObject * obj0 = 0 ;
13314 PyObject * obj1 = 0 ;
13315 char * kwnames[] = {
13316 (char *) "self",(char *) "width", NULL
13317 };
13318
13319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13321 if (!SWIG_IsOK(res1)) {
13322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13323 }
13324 arg1 = reinterpret_cast< wxGrid * >(argp1);
13325 ecode2 = SWIG_AsVal_int(obj1, &val2);
13326 if (!SWIG_IsOK(ecode2)) {
13327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13328 }
13329 arg2 = static_cast< int >(val2);
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 (arg1)->SetRowLabelSize(arg2);
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_Py_Void();
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj = 0;
13345 wxGrid *arg1 = (wxGrid *) 0 ;
13346 int arg2 ;
13347 void *argp1 = 0 ;
13348 int res1 = 0 ;
13349 int val2 ;
13350 int ecode2 = 0 ;
13351 PyObject * obj0 = 0 ;
13352 PyObject * obj1 = 0 ;
13353 char * kwnames[] = {
13354 (char *) "self",(char *) "height", NULL
13355 };
13356
13357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13359 if (!SWIG_IsOK(res1)) {
13360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13361 }
13362 arg1 = reinterpret_cast< wxGrid * >(argp1);
13363 ecode2 = SWIG_AsVal_int(obj1, &val2);
13364 if (!SWIG_IsOK(ecode2)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13366 }
13367 arg2 = static_cast< int >(val2);
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 (arg1)->SetColLabelSize(arg2);
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 resultobj = SWIG_Py_Void();
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj = 0;
13383 wxGrid *arg1 = (wxGrid *) 0 ;
13384 wxColour *arg2 = 0 ;
13385 void *argp1 = 0 ;
13386 int res1 = 0 ;
13387 wxColour temp2 ;
13388 PyObject * obj0 = 0 ;
13389 PyObject * obj1 = 0 ;
13390 char * kwnames[] = {
13391 (char *) "self",(char *)"arg2", NULL
13392 };
13393
13394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13396 if (!SWIG_IsOK(res1)) {
13397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13398 }
13399 arg1 = reinterpret_cast< wxGrid * >(argp1);
13400 {
13401 arg2 = &temp2;
13402 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13403 }
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13407 wxPyEndAllowThreads(__tstate);
13408 if (PyErr_Occurred()) SWIG_fail;
13409 }
13410 resultobj = SWIG_Py_Void();
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj = 0;
13419 wxGrid *arg1 = (wxGrid *) 0 ;
13420 wxColour *arg2 = 0 ;
13421 void *argp1 = 0 ;
13422 int res1 = 0 ;
13423 wxColour temp2 ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 char * kwnames[] = {
13427 (char *) "self",(char *)"arg2", NULL
13428 };
13429
13430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13432 if (!SWIG_IsOK(res1)) {
13433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13434 }
13435 arg1 = reinterpret_cast< wxGrid * >(argp1);
13436 {
13437 arg2 = &temp2;
13438 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13439 }
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 resultobj = SWIG_Py_Void();
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj = 0;
13455 wxGrid *arg1 = (wxGrid *) 0 ;
13456 wxFont *arg2 = 0 ;
13457 void *argp1 = 0 ;
13458 int res1 = 0 ;
13459 void *argp2 = 0 ;
13460 int res2 = 0 ;
13461 PyObject * obj0 = 0 ;
13462 PyObject * obj1 = 0 ;
13463 char * kwnames[] = {
13464 (char *) "self",(char *)"arg2", NULL
13465 };
13466
13467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13469 if (!SWIG_IsOK(res1)) {
13470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13471 }
13472 arg1 = reinterpret_cast< wxGrid * >(argp1);
13473 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13474 if (!SWIG_IsOK(res2)) {
13475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13476 }
13477 if (!argp2) {
13478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13479 }
13480 arg2 = reinterpret_cast< wxFont * >(argp2);
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 (arg1)->SetLabelFont((wxFont const &)*arg2);
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 resultobj = SWIG_Py_Void();
13488 return resultobj;
13489 fail:
13490 return NULL;
13491 }
13492
13493
13494 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj = 0;
13496 wxGrid *arg1 = (wxGrid *) 0 ;
13497 int arg2 ;
13498 int arg3 ;
13499 void *argp1 = 0 ;
13500 int res1 = 0 ;
13501 int val2 ;
13502 int ecode2 = 0 ;
13503 int val3 ;
13504 int ecode3 = 0 ;
13505 PyObject * obj0 = 0 ;
13506 PyObject * obj1 = 0 ;
13507 PyObject * obj2 = 0 ;
13508 char * kwnames[] = {
13509 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13510 };
13511
13512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13514 if (!SWIG_IsOK(res1)) {
13515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13516 }
13517 arg1 = reinterpret_cast< wxGrid * >(argp1);
13518 ecode2 = SWIG_AsVal_int(obj1, &val2);
13519 if (!SWIG_IsOK(ecode2)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13521 }
13522 arg2 = static_cast< int >(val2);
13523 ecode3 = SWIG_AsVal_int(obj2, &val3);
13524 if (!SWIG_IsOK(ecode3)) {
13525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13526 }
13527 arg3 = static_cast< int >(val3);
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 (arg1)->SetRowLabelAlignment(arg2,arg3);
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 resultobj = SWIG_Py_Void();
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxGrid *arg1 = (wxGrid *) 0 ;
13544 int arg2 ;
13545 int arg3 ;
13546 void *argp1 = 0 ;
13547 int res1 = 0 ;
13548 int val2 ;
13549 int ecode2 = 0 ;
13550 int val3 ;
13551 int ecode3 = 0 ;
13552 PyObject * obj0 = 0 ;
13553 PyObject * obj1 = 0 ;
13554 PyObject * obj2 = 0 ;
13555 char * kwnames[] = {
13556 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13557 };
13558
13559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13561 if (!SWIG_IsOK(res1)) {
13562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13563 }
13564 arg1 = reinterpret_cast< wxGrid * >(argp1);
13565 ecode2 = SWIG_AsVal_int(obj1, &val2);
13566 if (!SWIG_IsOK(ecode2)) {
13567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13568 }
13569 arg2 = static_cast< int >(val2);
13570 ecode3 = SWIG_AsVal_int(obj2, &val3);
13571 if (!SWIG_IsOK(ecode3)) {
13572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13573 }
13574 arg3 = static_cast< int >(val3);
13575 {
13576 PyThreadState* __tstate = wxPyBeginAllowThreads();
13577 (arg1)->SetColLabelAlignment(arg2,arg3);
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_Py_Void();
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = 0;
13590 wxGrid *arg1 = (wxGrid *) 0 ;
13591 int arg2 ;
13592 void *argp1 = 0 ;
13593 int res1 = 0 ;
13594 int val2 ;
13595 int ecode2 = 0 ;
13596 PyObject * obj0 = 0 ;
13597 PyObject * obj1 = 0 ;
13598 char * kwnames[] = {
13599 (char *) "self",(char *) "textOrientation", NULL
13600 };
13601
13602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13604 if (!SWIG_IsOK(res1)) {
13605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13606 }
13607 arg1 = reinterpret_cast< wxGrid * >(argp1);
13608 ecode2 = SWIG_AsVal_int(obj1, &val2);
13609 if (!SWIG_IsOK(ecode2)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13611 }
13612 arg2 = static_cast< int >(val2);
13613 {
13614 PyThreadState* __tstate = wxPyBeginAllowThreads();
13615 (arg1)->SetColLabelTextOrientation(arg2);
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 resultobj = SWIG_Py_Void();
13620 return resultobj;
13621 fail:
13622 return NULL;
13623 }
13624
13625
13626 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj = 0;
13628 wxGrid *arg1 = (wxGrid *) 0 ;
13629 int arg2 ;
13630 wxString *arg3 = 0 ;
13631 void *argp1 = 0 ;
13632 int res1 = 0 ;
13633 int val2 ;
13634 int ecode2 = 0 ;
13635 bool temp3 = false ;
13636 PyObject * obj0 = 0 ;
13637 PyObject * obj1 = 0 ;
13638 PyObject * obj2 = 0 ;
13639 char * kwnames[] = {
13640 (char *) "self",(char *) "row",(char *)"arg3", NULL
13641 };
13642
13643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13645 if (!SWIG_IsOK(res1)) {
13646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13647 }
13648 arg1 = reinterpret_cast< wxGrid * >(argp1);
13649 ecode2 = SWIG_AsVal_int(obj1, &val2);
13650 if (!SWIG_IsOK(ecode2)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13652 }
13653 arg2 = static_cast< int >(val2);
13654 {
13655 arg3 = wxString_in_helper(obj2);
13656 if (arg3 == NULL) SWIG_fail;
13657 temp3 = true;
13658 }
13659 {
13660 PyThreadState* __tstate = wxPyBeginAllowThreads();
13661 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_Py_Void();
13666 {
13667 if (temp3)
13668 delete arg3;
13669 }
13670 return resultobj;
13671 fail:
13672 {
13673 if (temp3)
13674 delete arg3;
13675 }
13676 return NULL;
13677 }
13678
13679
13680 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13681 PyObject *resultobj = 0;
13682 wxGrid *arg1 = (wxGrid *) 0 ;
13683 int arg2 ;
13684 wxString *arg3 = 0 ;
13685 void *argp1 = 0 ;
13686 int res1 = 0 ;
13687 int val2 ;
13688 int ecode2 = 0 ;
13689 bool temp3 = false ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 PyObject * obj2 = 0 ;
13693 char * kwnames[] = {
13694 (char *) "self",(char *) "col",(char *)"arg3", NULL
13695 };
13696
13697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) 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_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13701 }
13702 arg1 = reinterpret_cast< wxGrid * >(argp1);
13703 ecode2 = SWIG_AsVal_int(obj1, &val2);
13704 if (!SWIG_IsOK(ecode2)) {
13705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13706 }
13707 arg2 = static_cast< int >(val2);
13708 {
13709 arg3 = wxString_in_helper(obj2);
13710 if (arg3 == NULL) SWIG_fail;
13711 temp3 = true;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 resultobj = SWIG_Py_Void();
13720 {
13721 if (temp3)
13722 delete arg3;
13723 }
13724 return resultobj;
13725 fail:
13726 {
13727 if (temp3)
13728 delete arg3;
13729 }
13730 return NULL;
13731 }
13732
13733
13734 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13735 PyObject *resultobj = 0;
13736 wxGrid *arg1 = (wxGrid *) 0 ;
13737 wxColour *arg2 = 0 ;
13738 void *argp1 = 0 ;
13739 int res1 = 0 ;
13740 wxColour temp2 ;
13741 PyObject * obj0 = 0 ;
13742 PyObject * obj1 = 0 ;
13743 char * kwnames[] = {
13744 (char *) "self",(char *)"arg2", NULL
13745 };
13746
13747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13749 if (!SWIG_IsOK(res1)) {
13750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13751 }
13752 arg1 = reinterpret_cast< wxGrid * >(argp1);
13753 {
13754 arg2 = &temp2;
13755 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_Py_Void();
13764 return resultobj;
13765 fail:
13766 return NULL;
13767 }
13768
13769
13770 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj = 0;
13772 wxGrid *arg1 = (wxGrid *) 0 ;
13773 wxColour *arg2 = 0 ;
13774 void *argp1 = 0 ;
13775 int res1 = 0 ;
13776 wxColour temp2 ;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "self",(char *)"arg2", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13787 }
13788 arg1 = reinterpret_cast< wxGrid * >(argp1);
13789 {
13790 arg2 = &temp2;
13791 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13792 }
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13796 wxPyEndAllowThreads(__tstate);
13797 if (PyErr_Occurred()) SWIG_fail;
13798 }
13799 resultobj = SWIG_Py_Void();
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj = 0;
13808 wxGrid *arg1 = (wxGrid *) 0 ;
13809 int arg2 ;
13810 void *argp1 = 0 ;
13811 int res1 = 0 ;
13812 int val2 ;
13813 int ecode2 = 0 ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 char * kwnames[] = {
13817 (char *) "self",(char *) "width", NULL
13818 };
13819
13820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13822 if (!SWIG_IsOK(res1)) {
13823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13824 }
13825 arg1 = reinterpret_cast< wxGrid * >(argp1);
13826 ecode2 = SWIG_AsVal_int(obj1, &val2);
13827 if (!SWIG_IsOK(ecode2)) {
13828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13829 }
13830 arg2 = static_cast< int >(val2);
13831 {
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 (arg1)->SetCellHighlightPenWidth(arg2);
13834 wxPyEndAllowThreads(__tstate);
13835 if (PyErr_Occurred()) SWIG_fail;
13836 }
13837 resultobj = SWIG_Py_Void();
13838 return resultobj;
13839 fail:
13840 return NULL;
13841 }
13842
13843
13844 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13845 PyObject *resultobj = 0;
13846 wxGrid *arg1 = (wxGrid *) 0 ;
13847 int arg2 ;
13848 void *argp1 = 0 ;
13849 int res1 = 0 ;
13850 int val2 ;
13851 int ecode2 = 0 ;
13852 PyObject * obj0 = 0 ;
13853 PyObject * obj1 = 0 ;
13854 char * kwnames[] = {
13855 (char *) "self",(char *) "width", NULL
13856 };
13857
13858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13860 if (!SWIG_IsOK(res1)) {
13861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13862 }
13863 arg1 = reinterpret_cast< wxGrid * >(argp1);
13864 ecode2 = SWIG_AsVal_int(obj1, &val2);
13865 if (!SWIG_IsOK(ecode2)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13867 }
13868 arg2 = static_cast< int >(val2);
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 (arg1)->SetCellHighlightROPenWidth(arg2);
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 resultobj = SWIG_Py_Void();
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = 0;
13884 wxGrid *arg1 = (wxGrid *) 0 ;
13885 bool arg2 = (bool) true ;
13886 void *argp1 = 0 ;
13887 int res1 = 0 ;
13888 bool val2 ;
13889 int ecode2 = 0 ;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 char * kwnames[] = {
13893 (char *) "self",(char *) "enable", NULL
13894 };
13895
13896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13898 if (!SWIG_IsOK(res1)) {
13899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13900 }
13901 arg1 = reinterpret_cast< wxGrid * >(argp1);
13902 if (obj1) {
13903 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13904 if (!SWIG_IsOK(ecode2)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13906 }
13907 arg2 = static_cast< bool >(val2);
13908 }
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 (arg1)->EnableDragRowSize(arg2);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_Py_Void();
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13923 PyObject *resultobj = 0;
13924 wxGrid *arg1 = (wxGrid *) 0 ;
13925 void *argp1 = 0 ;
13926 int res1 = 0 ;
13927 PyObject *swig_obj[1] ;
13928
13929 if (!args) SWIG_fail;
13930 swig_obj[0] = args;
13931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13932 if (!SWIG_IsOK(res1)) {
13933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13934 }
13935 arg1 = reinterpret_cast< wxGrid * >(argp1);
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 (arg1)->DisableDragRowSize();
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 resultobj = SWIG_Py_Void();
13943 return resultobj;
13944 fail:
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13950 PyObject *resultobj = 0;
13951 wxGrid *arg1 = (wxGrid *) 0 ;
13952 bool result;
13953 void *argp1 = 0 ;
13954 int res1 = 0 ;
13955 PyObject *swig_obj[1] ;
13956
13957 if (!args) SWIG_fail;
13958 swig_obj[0] = args;
13959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13960 if (!SWIG_IsOK(res1)) {
13961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13962 }
13963 arg1 = reinterpret_cast< wxGrid * >(argp1);
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 result = (bool)(arg1)->CanDragRowSize();
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 {
13971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13972 }
13973 return resultobj;
13974 fail:
13975 return NULL;
13976 }
13977
13978
13979 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13980 PyObject *resultobj = 0;
13981 wxGrid *arg1 = (wxGrid *) 0 ;
13982 bool arg2 = (bool) true ;
13983 void *argp1 = 0 ;
13984 int res1 = 0 ;
13985 bool val2 ;
13986 int ecode2 = 0 ;
13987 PyObject * obj0 = 0 ;
13988 PyObject * obj1 = 0 ;
13989 char * kwnames[] = {
13990 (char *) "self",(char *) "enable", NULL
13991 };
13992
13993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13995 if (!SWIG_IsOK(res1)) {
13996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13997 }
13998 arg1 = reinterpret_cast< wxGrid * >(argp1);
13999 if (obj1) {
14000 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14001 if (!SWIG_IsOK(ecode2)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14003 }
14004 arg2 = static_cast< bool >(val2);
14005 }
14006 {
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 (arg1)->EnableDragColSize(arg2);
14009 wxPyEndAllowThreads(__tstate);
14010 if (PyErr_Occurred()) SWIG_fail;
14011 }
14012 resultobj = SWIG_Py_Void();
14013 return resultobj;
14014 fail:
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14020 PyObject *resultobj = 0;
14021 wxGrid *arg1 = (wxGrid *) 0 ;
14022 void *argp1 = 0 ;
14023 int res1 = 0 ;
14024 PyObject *swig_obj[1] ;
14025
14026 if (!args) SWIG_fail;
14027 swig_obj[0] = args;
14028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14029 if (!SWIG_IsOK(res1)) {
14030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14031 }
14032 arg1 = reinterpret_cast< wxGrid * >(argp1);
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 (arg1)->DisableDragColSize();
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_Py_Void();
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14047 PyObject *resultobj = 0;
14048 wxGrid *arg1 = (wxGrid *) 0 ;
14049 bool result;
14050 void *argp1 = 0 ;
14051 int res1 = 0 ;
14052 PyObject *swig_obj[1] ;
14053
14054 if (!args) SWIG_fail;
14055 swig_obj[0] = args;
14056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14059 }
14060 arg1 = reinterpret_cast< wxGrid * >(argp1);
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (bool)(arg1)->CanDragColSize();
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 {
14068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14069 }
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj = 0;
14078 wxGrid *arg1 = (wxGrid *) 0 ;
14079 bool arg2 = (bool) true ;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 bool val2 ;
14083 int ecode2 = 0 ;
14084 PyObject * obj0 = 0 ;
14085 PyObject * obj1 = 0 ;
14086 char * kwnames[] = {
14087 (char *) "self",(char *) "enable", NULL
14088 };
14089
14090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14092 if (!SWIG_IsOK(res1)) {
14093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14094 }
14095 arg1 = reinterpret_cast< wxGrid * >(argp1);
14096 if (obj1) {
14097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14098 if (!SWIG_IsOK(ecode2)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14100 }
14101 arg2 = static_cast< bool >(val2);
14102 }
14103 {
14104 PyThreadState* __tstate = wxPyBeginAllowThreads();
14105 (arg1)->EnableDragColMove(arg2);
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 resultobj = SWIG_Py_Void();
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14117 PyObject *resultobj = 0;
14118 wxGrid *arg1 = (wxGrid *) 0 ;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 PyObject *swig_obj[1] ;
14122
14123 if (!args) SWIG_fail;
14124 swig_obj[0] = args;
14125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14126 if (!SWIG_IsOK(res1)) {
14127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14128 }
14129 arg1 = reinterpret_cast< wxGrid * >(argp1);
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 (arg1)->DisableDragColMove();
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 resultobj = SWIG_Py_Void();
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 PyObject *resultobj = 0;
14145 wxGrid *arg1 = (wxGrid *) 0 ;
14146 bool result;
14147 void *argp1 = 0 ;
14148 int res1 = 0 ;
14149 PyObject *swig_obj[1] ;
14150
14151 if (!args) SWIG_fail;
14152 swig_obj[0] = args;
14153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14154 if (!SWIG_IsOK(res1)) {
14155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14156 }
14157 arg1 = reinterpret_cast< wxGrid * >(argp1);
14158 {
14159 PyThreadState* __tstate = wxPyBeginAllowThreads();
14160 result = (bool)(arg1)->CanDragColMove();
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 {
14165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14166 }
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj = 0;
14175 wxGrid *arg1 = (wxGrid *) 0 ;
14176 bool arg2 = (bool) true ;
14177 void *argp1 = 0 ;
14178 int res1 = 0 ;
14179 bool val2 ;
14180 int ecode2 = 0 ;
14181 PyObject * obj0 = 0 ;
14182 PyObject * obj1 = 0 ;
14183 char * kwnames[] = {
14184 (char *) "self",(char *) "enable", NULL
14185 };
14186
14187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14189 if (!SWIG_IsOK(res1)) {
14190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14191 }
14192 arg1 = reinterpret_cast< wxGrid * >(argp1);
14193 if (obj1) {
14194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14195 if (!SWIG_IsOK(ecode2)) {
14196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14197 }
14198 arg2 = static_cast< bool >(val2);
14199 }
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 (arg1)->EnableDragGridSize(arg2);
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_Py_Void();
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14214 PyObject *resultobj = 0;
14215 wxGrid *arg1 = (wxGrid *) 0 ;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 PyObject *swig_obj[1] ;
14219
14220 if (!args) SWIG_fail;
14221 swig_obj[0] = args;
14222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14223 if (!SWIG_IsOK(res1)) {
14224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14225 }
14226 arg1 = reinterpret_cast< wxGrid * >(argp1);
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 (arg1)->DisableDragGridSize();
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 resultobj = SWIG_Py_Void();
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *resultobj = 0;
14242 wxGrid *arg1 = (wxGrid *) 0 ;
14243 bool result;
14244 void *argp1 = 0 ;
14245 int res1 = 0 ;
14246 PyObject *swig_obj[1] ;
14247
14248 if (!args) SWIG_fail;
14249 swig_obj[0] = args;
14250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14251 if (!SWIG_IsOK(res1)) {
14252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14253 }
14254 arg1 = reinterpret_cast< wxGrid * >(argp1);
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (bool)(arg1)->CanDragGridSize();
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj = 0;
14272 wxGrid *arg1 = (wxGrid *) 0 ;
14273 bool arg2 = (bool) true ;
14274 void *argp1 = 0 ;
14275 int res1 = 0 ;
14276 bool val2 ;
14277 int ecode2 = 0 ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 char * kwnames[] = {
14281 (char *) "self",(char *) "enable", NULL
14282 };
14283
14284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14286 if (!SWIG_IsOK(res1)) {
14287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14288 }
14289 arg1 = reinterpret_cast< wxGrid * >(argp1);
14290 if (obj1) {
14291 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14292 if (!SWIG_IsOK(ecode2)) {
14293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14294 }
14295 arg2 = static_cast< bool >(val2);
14296 }
14297 {
14298 PyThreadState* __tstate = wxPyBeginAllowThreads();
14299 (arg1)->EnableDragCell(arg2);
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 resultobj = SWIG_Py_Void();
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311 PyObject *resultobj = 0;
14312 wxGrid *arg1 = (wxGrid *) 0 ;
14313 void *argp1 = 0 ;
14314 int res1 = 0 ;
14315 PyObject *swig_obj[1] ;
14316
14317 if (!args) SWIG_fail;
14318 swig_obj[0] = args;
14319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14320 if (!SWIG_IsOK(res1)) {
14321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14322 }
14323 arg1 = reinterpret_cast< wxGrid * >(argp1);
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 (arg1)->DisableDragCell();
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 resultobj = SWIG_Py_Void();
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14338 PyObject *resultobj = 0;
14339 wxGrid *arg1 = (wxGrid *) 0 ;
14340 bool result;
14341 void *argp1 = 0 ;
14342 int res1 = 0 ;
14343 PyObject *swig_obj[1] ;
14344
14345 if (!args) SWIG_fail;
14346 swig_obj[0] = args;
14347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14348 if (!SWIG_IsOK(res1)) {
14349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14350 }
14351 arg1 = reinterpret_cast< wxGrid * >(argp1);
14352 {
14353 PyThreadState* __tstate = wxPyBeginAllowThreads();
14354 result = (bool)(arg1)->CanDragCell();
14355 wxPyEndAllowThreads(__tstate);
14356 if (PyErr_Occurred()) SWIG_fail;
14357 }
14358 {
14359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14360 }
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14368 PyObject *resultobj = 0;
14369 wxGrid *arg1 = (wxGrid *) 0 ;
14370 int arg2 ;
14371 int arg3 ;
14372 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14373 void *argp1 = 0 ;
14374 int res1 = 0 ;
14375 int val2 ;
14376 int ecode2 = 0 ;
14377 int val3 ;
14378 int ecode3 = 0 ;
14379 void *argp4 = 0 ;
14380 int res4 = 0 ;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 PyObject * obj2 = 0 ;
14384 PyObject * obj3 = 0 ;
14385 char * kwnames[] = {
14386 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14387 };
14388
14389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14391 if (!SWIG_IsOK(res1)) {
14392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14393 }
14394 arg1 = reinterpret_cast< wxGrid * >(argp1);
14395 ecode2 = SWIG_AsVal_int(obj1, &val2);
14396 if (!SWIG_IsOK(ecode2)) {
14397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14398 }
14399 arg2 = static_cast< int >(val2);
14400 ecode3 = SWIG_AsVal_int(obj2, &val3);
14401 if (!SWIG_IsOK(ecode3)) {
14402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14403 }
14404 arg3 = static_cast< int >(val3);
14405 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14406 if (!SWIG_IsOK(res4)) {
14407 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14408 }
14409 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 (arg1)->SetAttr(arg2,arg3,arg4);
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 resultobj = SWIG_Py_Void();
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14424 PyObject *resultobj = 0;
14425 wxGrid *arg1 = (wxGrid *) 0 ;
14426 int arg2 ;
14427 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 int val2 ;
14431 int ecode2 = 0 ;
14432 void *argp3 = 0 ;
14433 int res3 = 0 ;
14434 PyObject * obj0 = 0 ;
14435 PyObject * obj1 = 0 ;
14436 PyObject * obj2 = 0 ;
14437 char * kwnames[] = {
14438 (char *) "self",(char *) "row",(char *) "attr", NULL
14439 };
14440
14441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14443 if (!SWIG_IsOK(res1)) {
14444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14445 }
14446 arg1 = reinterpret_cast< wxGrid * >(argp1);
14447 ecode2 = SWIG_AsVal_int(obj1, &val2);
14448 if (!SWIG_IsOK(ecode2)) {
14449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14450 }
14451 arg2 = static_cast< int >(val2);
14452 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14453 if (!SWIG_IsOK(res3)) {
14454 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14455 }
14456 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 (arg1)->SetRowAttr(arg2,arg3);
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 resultobj = SWIG_Py_Void();
14464 return resultobj;
14465 fail:
14466 return NULL;
14467 }
14468
14469
14470 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14471 PyObject *resultobj = 0;
14472 wxGrid *arg1 = (wxGrid *) 0 ;
14473 int arg2 ;
14474 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14475 void *argp1 = 0 ;
14476 int res1 = 0 ;
14477 int val2 ;
14478 int ecode2 = 0 ;
14479 void *argp3 = 0 ;
14480 int res3 = 0 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 char * kwnames[] = {
14485 (char *) "self",(char *) "col",(char *) "attr", NULL
14486 };
14487
14488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14492 }
14493 arg1 = reinterpret_cast< wxGrid * >(argp1);
14494 ecode2 = SWIG_AsVal_int(obj1, &val2);
14495 if (!SWIG_IsOK(ecode2)) {
14496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14497 }
14498 arg2 = static_cast< int >(val2);
14499 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14500 if (!SWIG_IsOK(res3)) {
14501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14502 }
14503 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 (arg1)->SetColAttr(arg2,arg3);
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 resultobj = SWIG_Py_Void();
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxGrid *arg1 = (wxGrid *) 0 ;
14520 int arg2 ;
14521 int arg3 ;
14522 wxGridCellAttr *result = 0 ;
14523 void *argp1 = 0 ;
14524 int res1 = 0 ;
14525 int val2 ;
14526 int ecode2 = 0 ;
14527 int val3 ;
14528 int ecode3 = 0 ;
14529 PyObject * obj0 = 0 ;
14530 PyObject * obj1 = 0 ;
14531 PyObject * obj2 = 0 ;
14532 char * kwnames[] = {
14533 (char *) "self",(char *) "row",(char *) "col", NULL
14534 };
14535
14536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14538 if (!SWIG_IsOK(res1)) {
14539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14540 }
14541 arg1 = reinterpret_cast< wxGrid * >(argp1);
14542 ecode2 = SWIG_AsVal_int(obj1, &val2);
14543 if (!SWIG_IsOK(ecode2)) {
14544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14545 }
14546 arg2 = static_cast< int >(val2);
14547 ecode3 = SWIG_AsVal_int(obj2, &val3);
14548 if (!SWIG_IsOK(ecode3)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14550 }
14551 arg3 = static_cast< int >(val3);
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 {
14559 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14560 }
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14568 PyObject *resultobj = 0;
14569 wxGrid *arg1 = (wxGrid *) 0 ;
14570 int arg2 ;
14571 void *argp1 = 0 ;
14572 int res1 = 0 ;
14573 int val2 ;
14574 int ecode2 = 0 ;
14575 PyObject * obj0 = 0 ;
14576 PyObject * obj1 = 0 ;
14577 char * kwnames[] = {
14578 (char *) "self",(char *) "col", NULL
14579 };
14580
14581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14583 if (!SWIG_IsOK(res1)) {
14584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14585 }
14586 arg1 = reinterpret_cast< wxGrid * >(argp1);
14587 ecode2 = SWIG_AsVal_int(obj1, &val2);
14588 if (!SWIG_IsOK(ecode2)) {
14589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14590 }
14591 arg2 = static_cast< int >(val2);
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 (arg1)->SetColFormatBool(arg2);
14595 wxPyEndAllowThreads(__tstate);
14596 if (PyErr_Occurred()) SWIG_fail;
14597 }
14598 resultobj = SWIG_Py_Void();
14599 return resultobj;
14600 fail:
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14606 PyObject *resultobj = 0;
14607 wxGrid *arg1 = (wxGrid *) 0 ;
14608 int arg2 ;
14609 void *argp1 = 0 ;
14610 int res1 = 0 ;
14611 int val2 ;
14612 int ecode2 = 0 ;
14613 PyObject * obj0 = 0 ;
14614 PyObject * obj1 = 0 ;
14615 char * kwnames[] = {
14616 (char *) "self",(char *) "col", NULL
14617 };
14618
14619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14621 if (!SWIG_IsOK(res1)) {
14622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14623 }
14624 arg1 = reinterpret_cast< wxGrid * >(argp1);
14625 ecode2 = SWIG_AsVal_int(obj1, &val2);
14626 if (!SWIG_IsOK(ecode2)) {
14627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14628 }
14629 arg2 = static_cast< int >(val2);
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 (arg1)->SetColFormatNumber(arg2);
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 resultobj = SWIG_Py_Void();
14637 return resultobj;
14638 fail:
14639 return NULL;
14640 }
14641
14642
14643 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj = 0;
14645 wxGrid *arg1 = (wxGrid *) 0 ;
14646 int arg2 ;
14647 int arg3 = (int) -1 ;
14648 int arg4 = (int) -1 ;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 int val2 ;
14652 int ecode2 = 0 ;
14653 int val3 ;
14654 int ecode3 = 0 ;
14655 int val4 ;
14656 int ecode4 = 0 ;
14657 PyObject * obj0 = 0 ;
14658 PyObject * obj1 = 0 ;
14659 PyObject * obj2 = 0 ;
14660 PyObject * obj3 = 0 ;
14661 char * kwnames[] = {
14662 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14663 };
14664
14665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14667 if (!SWIG_IsOK(res1)) {
14668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14669 }
14670 arg1 = reinterpret_cast< wxGrid * >(argp1);
14671 ecode2 = SWIG_AsVal_int(obj1, &val2);
14672 if (!SWIG_IsOK(ecode2)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14674 }
14675 arg2 = static_cast< int >(val2);
14676 if (obj2) {
14677 ecode3 = SWIG_AsVal_int(obj2, &val3);
14678 if (!SWIG_IsOK(ecode3)) {
14679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14680 }
14681 arg3 = static_cast< int >(val3);
14682 }
14683 if (obj3) {
14684 ecode4 = SWIG_AsVal_int(obj3, &val4);
14685 if (!SWIG_IsOK(ecode4)) {
14686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14687 }
14688 arg4 = static_cast< int >(val4);
14689 }
14690 {
14691 PyThreadState* __tstate = wxPyBeginAllowThreads();
14692 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 resultobj = SWIG_Py_Void();
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj = 0;
14705 wxGrid *arg1 = (wxGrid *) 0 ;
14706 int arg2 ;
14707 wxString *arg3 = 0 ;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 int val2 ;
14711 int ecode2 = 0 ;
14712 bool temp3 = false ;
14713 PyObject * obj0 = 0 ;
14714 PyObject * obj1 = 0 ;
14715 PyObject * obj2 = 0 ;
14716 char * kwnames[] = {
14717 (char *) "self",(char *) "col",(char *) "typeName", NULL
14718 };
14719
14720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14722 if (!SWIG_IsOK(res1)) {
14723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14724 }
14725 arg1 = reinterpret_cast< wxGrid * >(argp1);
14726 ecode2 = SWIG_AsVal_int(obj1, &val2);
14727 if (!SWIG_IsOK(ecode2)) {
14728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14729 }
14730 arg2 = static_cast< int >(val2);
14731 {
14732 arg3 = wxString_in_helper(obj2);
14733 if (arg3 == NULL) SWIG_fail;
14734 temp3 = true;
14735 }
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 resultobj = SWIG_Py_Void();
14743 {
14744 if (temp3)
14745 delete arg3;
14746 }
14747 return resultobj;
14748 fail:
14749 {
14750 if (temp3)
14751 delete arg3;
14752 }
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14758 PyObject *resultobj = 0;
14759 wxGrid *arg1 = (wxGrid *) 0 ;
14760 bool arg2 = (bool) true ;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 bool val2 ;
14764 int ecode2 = 0 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 char * kwnames[] = {
14768 (char *) "self",(char *) "enable", NULL
14769 };
14770
14771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14773 if (!SWIG_IsOK(res1)) {
14774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14775 }
14776 arg1 = reinterpret_cast< wxGrid * >(argp1);
14777 if (obj1) {
14778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14779 if (!SWIG_IsOK(ecode2)) {
14780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14781 }
14782 arg2 = static_cast< bool >(val2);
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 (arg1)->EnableGridLines(arg2);
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = SWIG_Py_Void();
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 PyObject *resultobj = 0;
14799 wxGrid *arg1 = (wxGrid *) 0 ;
14800 bool result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 PyObject *swig_obj[1] ;
14804
14805 if (!args) SWIG_fail;
14806 swig_obj[0] = args;
14807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14810 }
14811 arg1 = reinterpret_cast< wxGrid * >(argp1);
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 result = (bool)(arg1)->GridLinesEnabled();
14815 wxPyEndAllowThreads(__tstate);
14816 if (PyErr_Occurred()) SWIG_fail;
14817 }
14818 {
14819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14820 }
14821 return resultobj;
14822 fail:
14823 return NULL;
14824 }
14825
14826
14827 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14828 PyObject *resultobj = 0;
14829 wxGrid *arg1 = (wxGrid *) 0 ;
14830 int result;
14831 void *argp1 = 0 ;
14832 int res1 = 0 ;
14833 PyObject *swig_obj[1] ;
14834
14835 if (!args) SWIG_fail;
14836 swig_obj[0] = args;
14837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14838 if (!SWIG_IsOK(res1)) {
14839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14840 }
14841 arg1 = reinterpret_cast< wxGrid * >(argp1);
14842 {
14843 PyThreadState* __tstate = wxPyBeginAllowThreads();
14844 result = (int)(arg1)->GetDefaultRowSize();
14845 wxPyEndAllowThreads(__tstate);
14846 if (PyErr_Occurred()) SWIG_fail;
14847 }
14848 resultobj = SWIG_From_int(static_cast< int >(result));
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14856 PyObject *resultobj = 0;
14857 wxGrid *arg1 = (wxGrid *) 0 ;
14858 int arg2 ;
14859 int result;
14860 void *argp1 = 0 ;
14861 int res1 = 0 ;
14862 int val2 ;
14863 int ecode2 = 0 ;
14864 PyObject * obj0 = 0 ;
14865 PyObject * obj1 = 0 ;
14866 char * kwnames[] = {
14867 (char *) "self",(char *) "row", NULL
14868 };
14869
14870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14872 if (!SWIG_IsOK(res1)) {
14873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14874 }
14875 arg1 = reinterpret_cast< wxGrid * >(argp1);
14876 ecode2 = SWIG_AsVal_int(obj1, &val2);
14877 if (!SWIG_IsOK(ecode2)) {
14878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14879 }
14880 arg2 = static_cast< int >(val2);
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (int)(arg1)->GetRowSize(arg2);
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 resultobj = SWIG_From_int(static_cast< int >(result));
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14895 PyObject *resultobj = 0;
14896 wxGrid *arg1 = (wxGrid *) 0 ;
14897 int result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 PyObject *swig_obj[1] ;
14901
14902 if (!args) SWIG_fail;
14903 swig_obj[0] = args;
14904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14905 if (!SWIG_IsOK(res1)) {
14906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14907 }
14908 arg1 = reinterpret_cast< wxGrid * >(argp1);
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (int)(arg1)->GetDefaultColSize();
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 resultobj = SWIG_From_int(static_cast< int >(result));
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14923 PyObject *resultobj = 0;
14924 wxGrid *arg1 = (wxGrid *) 0 ;
14925 int arg2 ;
14926 int result;
14927 void *argp1 = 0 ;
14928 int res1 = 0 ;
14929 int val2 ;
14930 int ecode2 = 0 ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 char * kwnames[] = {
14934 (char *) "self",(char *) "col", NULL
14935 };
14936
14937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14941 }
14942 arg1 = reinterpret_cast< wxGrid * >(argp1);
14943 ecode2 = SWIG_AsVal_int(obj1, &val2);
14944 if (!SWIG_IsOK(ecode2)) {
14945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14946 }
14947 arg2 = static_cast< int >(val2);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (int)(arg1)->GetColSize(arg2);
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 resultobj = SWIG_From_int(static_cast< int >(result));
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14962 PyObject *resultobj = 0;
14963 wxGrid *arg1 = (wxGrid *) 0 ;
14964 wxColour result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 PyObject *swig_obj[1] ;
14968
14969 if (!args) SWIG_fail;
14970 swig_obj[0] = args;
14971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14972 if (!SWIG_IsOK(res1)) {
14973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14974 }
14975 arg1 = reinterpret_cast< wxGrid * >(argp1);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (arg1)->GetDefaultCellBackgroundColour();
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = 0;
14991 wxGrid *arg1 = (wxGrid *) 0 ;
14992 int arg2 ;
14993 int arg3 ;
14994 wxColour result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 int val2 ;
14998 int ecode2 = 0 ;
14999 int val3 ;
15000 int ecode3 = 0 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 PyObject * obj2 = 0 ;
15004 char * kwnames[] = {
15005 (char *) "self",(char *) "row",(char *) "col", NULL
15006 };
15007
15008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15012 }
15013 arg1 = reinterpret_cast< wxGrid * >(argp1);
15014 ecode2 = SWIG_AsVal_int(obj1, &val2);
15015 if (!SWIG_IsOK(ecode2)) {
15016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15017 }
15018 arg2 = static_cast< int >(val2);
15019 ecode3 = SWIG_AsVal_int(obj2, &val3);
15020 if (!SWIG_IsOK(ecode3)) {
15021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15022 }
15023 arg3 = static_cast< int >(val3);
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15031 return resultobj;
15032 fail:
15033 return NULL;
15034 }
15035
15036
15037 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15038 PyObject *resultobj = 0;
15039 wxGrid *arg1 = (wxGrid *) 0 ;
15040 wxColour result;
15041 void *argp1 = 0 ;
15042 int res1 = 0 ;
15043 PyObject *swig_obj[1] ;
15044
15045 if (!args) SWIG_fail;
15046 swig_obj[0] = args;
15047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15048 if (!SWIG_IsOK(res1)) {
15049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15050 }
15051 arg1 = reinterpret_cast< wxGrid * >(argp1);
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (arg1)->GetDefaultCellTextColour();
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = 0;
15067 wxGrid *arg1 = (wxGrid *) 0 ;
15068 int arg2 ;
15069 int arg3 ;
15070 wxColour result;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 int val2 ;
15074 int ecode2 = 0 ;
15075 int val3 ;
15076 int ecode3 = 0 ;
15077 PyObject * obj0 = 0 ;
15078 PyObject * obj1 = 0 ;
15079 PyObject * obj2 = 0 ;
15080 char * kwnames[] = {
15081 (char *) "self",(char *) "row",(char *) "col", NULL
15082 };
15083
15084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15088 }
15089 arg1 = reinterpret_cast< wxGrid * >(argp1);
15090 ecode2 = SWIG_AsVal_int(obj1, &val2);
15091 if (!SWIG_IsOK(ecode2)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15093 }
15094 arg2 = static_cast< int >(val2);
15095 ecode3 = SWIG_AsVal_int(obj2, &val3);
15096 if (!SWIG_IsOK(ecode3)) {
15097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15098 }
15099 arg3 = static_cast< int >(val3);
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (arg1)->GetCellTextColour(arg2,arg3);
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15107 return resultobj;
15108 fail:
15109 return NULL;
15110 }
15111
15112
15113 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15114 PyObject *resultobj = 0;
15115 wxGrid *arg1 = (wxGrid *) 0 ;
15116 wxFont result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 PyObject *swig_obj[1] ;
15120
15121 if (!args) SWIG_fail;
15122 swig_obj[0] = args;
15123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15124 if (!SWIG_IsOK(res1)) {
15125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15126 }
15127 arg1 = reinterpret_cast< wxGrid * >(argp1);
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (arg1)->GetDefaultCellFont();
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15135 return resultobj;
15136 fail:
15137 return NULL;
15138 }
15139
15140
15141 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15142 PyObject *resultobj = 0;
15143 wxGrid *arg1 = (wxGrid *) 0 ;
15144 int arg2 ;
15145 int arg3 ;
15146 wxFont result;
15147 void *argp1 = 0 ;
15148 int res1 = 0 ;
15149 int val2 ;
15150 int ecode2 = 0 ;
15151 int val3 ;
15152 int ecode3 = 0 ;
15153 PyObject * obj0 = 0 ;
15154 PyObject * obj1 = 0 ;
15155 PyObject * obj2 = 0 ;
15156 char * kwnames[] = {
15157 (char *) "self",(char *) "row",(char *) "col", NULL
15158 };
15159
15160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15162 if (!SWIG_IsOK(res1)) {
15163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15164 }
15165 arg1 = reinterpret_cast< wxGrid * >(argp1);
15166 ecode2 = SWIG_AsVal_int(obj1, &val2);
15167 if (!SWIG_IsOK(ecode2)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15169 }
15170 arg2 = static_cast< int >(val2);
15171 ecode3 = SWIG_AsVal_int(obj2, &val3);
15172 if (!SWIG_IsOK(ecode3)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15174 }
15175 arg3 = static_cast< int >(val3);
15176 {
15177 PyThreadState* __tstate = wxPyBeginAllowThreads();
15178 result = (arg1)->GetCellFont(arg2,arg3);
15179 wxPyEndAllowThreads(__tstate);
15180 if (PyErr_Occurred()) SWIG_fail;
15181 }
15182 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15183 return resultobj;
15184 fail:
15185 return NULL;
15186 }
15187
15188
15189 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15190 PyObject *resultobj = 0;
15191 wxGrid *arg1 = (wxGrid *) 0 ;
15192 int *arg2 = (int *) 0 ;
15193 int *arg3 = (int *) 0 ;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 int temp2 ;
15197 int res2 = SWIG_TMPOBJ ;
15198 int temp3 ;
15199 int res3 = SWIG_TMPOBJ ;
15200 PyObject *swig_obj[1] ;
15201
15202 arg2 = &temp2;
15203 arg3 = &temp3;
15204 if (!args) SWIG_fail;
15205 swig_obj[0] = args;
15206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15207 if (!SWIG_IsOK(res1)) {
15208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15209 }
15210 arg1 = reinterpret_cast< wxGrid * >(argp1);
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15214 wxPyEndAllowThreads(__tstate);
15215 if (PyErr_Occurred()) SWIG_fail;
15216 }
15217 resultobj = SWIG_Py_Void();
15218 if (SWIG_IsTmpObj(res2)) {
15219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15220 } else {
15221 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15223 }
15224 if (SWIG_IsTmpObj(res3)) {
15225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15226 } else {
15227 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15229 }
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = 0;
15238 wxGrid *arg1 = (wxGrid *) 0 ;
15239 int arg2 ;
15240 int arg3 ;
15241 int *arg4 = (int *) 0 ;
15242 int *arg5 = (int *) 0 ;
15243 void *argp1 = 0 ;
15244 int res1 = 0 ;
15245 int val2 ;
15246 int ecode2 = 0 ;
15247 int val3 ;
15248 int ecode3 = 0 ;
15249 int temp4 ;
15250 int res4 = SWIG_TMPOBJ ;
15251 int temp5 ;
15252 int res5 = SWIG_TMPOBJ ;
15253 PyObject * obj0 = 0 ;
15254 PyObject * obj1 = 0 ;
15255 PyObject * obj2 = 0 ;
15256 char * kwnames[] = {
15257 (char *) "self",(char *) "row",(char *) "col", NULL
15258 };
15259
15260 arg4 = &temp4;
15261 arg5 = &temp5;
15262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15264 if (!SWIG_IsOK(res1)) {
15265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15266 }
15267 arg1 = reinterpret_cast< wxGrid * >(argp1);
15268 ecode2 = SWIG_AsVal_int(obj1, &val2);
15269 if (!SWIG_IsOK(ecode2)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15271 }
15272 arg2 = static_cast< int >(val2);
15273 ecode3 = SWIG_AsVal_int(obj2, &val3);
15274 if (!SWIG_IsOK(ecode3)) {
15275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15276 }
15277 arg3 = static_cast< int >(val3);
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_Py_Void();
15285 if (SWIG_IsTmpObj(res4)) {
15286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15287 } else {
15288 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15290 }
15291 if (SWIG_IsTmpObj(res5)) {
15292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15293 } else {
15294 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15295 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15296 }
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15304 PyObject *resultobj = 0;
15305 wxGrid *arg1 = (wxGrid *) 0 ;
15306 bool result;
15307 void *argp1 = 0 ;
15308 int res1 = 0 ;
15309 PyObject *swig_obj[1] ;
15310
15311 if (!args) SWIG_fail;
15312 swig_obj[0] = args;
15313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15316 }
15317 arg1 = reinterpret_cast< wxGrid * >(argp1);
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (bool)(arg1)->GetDefaultCellOverflow();
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 {
15325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15326 }
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj = 0;
15335 wxGrid *arg1 = (wxGrid *) 0 ;
15336 int arg2 ;
15337 int arg3 ;
15338 bool result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 int val2 ;
15342 int ecode2 = 0 ;
15343 int val3 ;
15344 int ecode3 = 0 ;
15345 PyObject * obj0 = 0 ;
15346 PyObject * obj1 = 0 ;
15347 PyObject * obj2 = 0 ;
15348 char * kwnames[] = {
15349 (char *) "self",(char *) "row",(char *) "col", NULL
15350 };
15351
15352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15354 if (!SWIG_IsOK(res1)) {
15355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15356 }
15357 arg1 = reinterpret_cast< wxGrid * >(argp1);
15358 ecode2 = SWIG_AsVal_int(obj1, &val2);
15359 if (!SWIG_IsOK(ecode2)) {
15360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15361 }
15362 arg2 = static_cast< int >(val2);
15363 ecode3 = SWIG_AsVal_int(obj2, &val3);
15364 if (!SWIG_IsOK(ecode3)) {
15365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15366 }
15367 arg3 = static_cast< int >(val3);
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 {
15375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15376 }
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj = 0;
15385 wxGrid *arg1 = (wxGrid *) 0 ;
15386 int arg2 ;
15387 int arg3 ;
15388 int *arg4 = (int *) 0 ;
15389 int *arg5 = (int *) 0 ;
15390 void *argp1 = 0 ;
15391 int res1 = 0 ;
15392 int val2 ;
15393 int ecode2 = 0 ;
15394 int val3 ;
15395 int ecode3 = 0 ;
15396 int temp4 ;
15397 int res4 = SWIG_TMPOBJ ;
15398 int temp5 ;
15399 int res5 = SWIG_TMPOBJ ;
15400 PyObject * obj0 = 0 ;
15401 PyObject * obj1 = 0 ;
15402 PyObject * obj2 = 0 ;
15403 char * kwnames[] = {
15404 (char *) "self",(char *) "row",(char *) "col", NULL
15405 };
15406
15407 arg4 = &temp4;
15408 arg5 = &temp5;
15409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15413 }
15414 arg1 = reinterpret_cast< wxGrid * >(argp1);
15415 ecode2 = SWIG_AsVal_int(obj1, &val2);
15416 if (!SWIG_IsOK(ecode2)) {
15417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15418 }
15419 arg2 = static_cast< int >(val2);
15420 ecode3 = SWIG_AsVal_int(obj2, &val3);
15421 if (!SWIG_IsOK(ecode3)) {
15422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15423 }
15424 arg3 = static_cast< int >(val3);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = SWIG_Py_Void();
15432 if (SWIG_IsTmpObj(res4)) {
15433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15434 } else {
15435 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15437 }
15438 if (SWIG_IsTmpObj(res5)) {
15439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15440 } else {
15441 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15443 }
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj = 0;
15452 wxGrid *arg1 = (wxGrid *) 0 ;
15453 int arg2 ;
15454 bool arg3 = (bool) false ;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 int val2 ;
15458 int ecode2 = 0 ;
15459 bool val3 ;
15460 int ecode3 = 0 ;
15461 PyObject * obj0 = 0 ;
15462 PyObject * obj1 = 0 ;
15463 PyObject * obj2 = 0 ;
15464 char * kwnames[] = {
15465 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15466 };
15467
15468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15472 }
15473 arg1 = reinterpret_cast< wxGrid * >(argp1);
15474 ecode2 = SWIG_AsVal_int(obj1, &val2);
15475 if (!SWIG_IsOK(ecode2)) {
15476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15477 }
15478 arg2 = static_cast< int >(val2);
15479 if (obj2) {
15480 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15481 if (!SWIG_IsOK(ecode3)) {
15482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15483 }
15484 arg3 = static_cast< bool >(val3);
15485 }
15486 {
15487 PyThreadState* __tstate = wxPyBeginAllowThreads();
15488 (arg1)->SetDefaultRowSize(arg2,arg3);
15489 wxPyEndAllowThreads(__tstate);
15490 if (PyErr_Occurred()) SWIG_fail;
15491 }
15492 resultobj = SWIG_Py_Void();
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj = 0;
15501 wxGrid *arg1 = (wxGrid *) 0 ;
15502 int arg2 ;
15503 int arg3 ;
15504 void *argp1 = 0 ;
15505 int res1 = 0 ;
15506 int val2 ;
15507 int ecode2 = 0 ;
15508 int val3 ;
15509 int ecode3 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 PyObject * obj2 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "row",(char *) "height", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15521 }
15522 arg1 = reinterpret_cast< wxGrid * >(argp1);
15523 ecode2 = SWIG_AsVal_int(obj1, &val2);
15524 if (!SWIG_IsOK(ecode2)) {
15525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15526 }
15527 arg2 = static_cast< int >(val2);
15528 ecode3 = SWIG_AsVal_int(obj2, &val3);
15529 if (!SWIG_IsOK(ecode3)) {
15530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15531 }
15532 arg3 = static_cast< int >(val3);
15533 {
15534 PyThreadState* __tstate = wxPyBeginAllowThreads();
15535 (arg1)->SetRowSize(arg2,arg3);
15536 wxPyEndAllowThreads(__tstate);
15537 if (PyErr_Occurred()) SWIG_fail;
15538 }
15539 resultobj = SWIG_Py_Void();
15540 return resultobj;
15541 fail:
15542 return NULL;
15543 }
15544
15545
15546 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15547 PyObject *resultobj = 0;
15548 wxGrid *arg1 = (wxGrid *) 0 ;
15549 int arg2 ;
15550 bool arg3 = (bool) false ;
15551 void *argp1 = 0 ;
15552 int res1 = 0 ;
15553 int val2 ;
15554 int ecode2 = 0 ;
15555 bool val3 ;
15556 int ecode3 = 0 ;
15557 PyObject * obj0 = 0 ;
15558 PyObject * obj1 = 0 ;
15559 PyObject * obj2 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15568 }
15569 arg1 = reinterpret_cast< wxGrid * >(argp1);
15570 ecode2 = SWIG_AsVal_int(obj1, &val2);
15571 if (!SWIG_IsOK(ecode2)) {
15572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15573 }
15574 arg2 = static_cast< int >(val2);
15575 if (obj2) {
15576 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15577 if (!SWIG_IsOK(ecode3)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15579 }
15580 arg3 = static_cast< bool >(val3);
15581 }
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 (arg1)->SetDefaultColSize(arg2,arg3);
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 resultobj = SWIG_Py_Void();
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj = 0;
15597 wxGrid *arg1 = (wxGrid *) 0 ;
15598 int arg2 ;
15599 int arg3 ;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 int val2 ;
15603 int ecode2 = 0 ;
15604 int val3 ;
15605 int ecode3 = 0 ;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 PyObject * obj2 = 0 ;
15609 char * kwnames[] = {
15610 (char *) "self",(char *) "col",(char *) "width", NULL
15611 };
15612
15613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15615 if (!SWIG_IsOK(res1)) {
15616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15617 }
15618 arg1 = reinterpret_cast< wxGrid * >(argp1);
15619 ecode2 = SWIG_AsVal_int(obj1, &val2);
15620 if (!SWIG_IsOK(ecode2)) {
15621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15622 }
15623 arg2 = static_cast< int >(val2);
15624 ecode3 = SWIG_AsVal_int(obj2, &val3);
15625 if (!SWIG_IsOK(ecode3)) {
15626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15627 }
15628 arg3 = static_cast< int >(val3);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 (arg1)->SetColSize(arg2,arg3);
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 resultobj = SWIG_Py_Void();
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj = 0;
15644 wxGrid *arg1 = (wxGrid *) 0 ;
15645 int arg2 ;
15646 int result;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 int val2 ;
15650 int ecode2 = 0 ;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 char * kwnames[] = {
15654 (char *) "self",(char *) "colPos", NULL
15655 };
15656
15657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15661 }
15662 arg1 = reinterpret_cast< wxGrid * >(argp1);
15663 ecode2 = SWIG_AsVal_int(obj1, &val2);
15664 if (!SWIG_IsOK(ecode2)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15666 }
15667 arg2 = static_cast< int >(val2);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_From_int(static_cast< int >(result));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxGrid *arg1 = (wxGrid *) 0 ;
15684 int arg2 ;
15685 int arg3 ;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 int val2 ;
15689 int ecode2 = 0 ;
15690 int val3 ;
15691 int ecode3 = 0 ;
15692 PyObject * obj0 = 0 ;
15693 PyObject * obj1 = 0 ;
15694 PyObject * obj2 = 0 ;
15695 char * kwnames[] = {
15696 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15697 };
15698
15699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15703 }
15704 arg1 = reinterpret_cast< wxGrid * >(argp1);
15705 ecode2 = SWIG_AsVal_int(obj1, &val2);
15706 if (!SWIG_IsOK(ecode2)) {
15707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15708 }
15709 arg2 = static_cast< int >(val2);
15710 ecode3 = SWIG_AsVal_int(obj2, &val3);
15711 if (!SWIG_IsOK(ecode3)) {
15712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15713 }
15714 arg3 = static_cast< int >(val3);
15715 {
15716 PyThreadState* __tstate = wxPyBeginAllowThreads();
15717 (arg1)->SetColPos(arg2,arg3);
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 resultobj = SWIG_Py_Void();
15722 return resultobj;
15723 fail:
15724 return NULL;
15725 }
15726
15727
15728 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15729 PyObject *resultobj = 0;
15730 wxGrid *arg1 = (wxGrid *) 0 ;
15731 int arg2 ;
15732 int result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 int val2 ;
15736 int ecode2 = 0 ;
15737 PyObject * obj0 = 0 ;
15738 PyObject * obj1 = 0 ;
15739 char * kwnames[] = {
15740 (char *) "self",(char *) "colID", NULL
15741 };
15742
15743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15745 if (!SWIG_IsOK(res1)) {
15746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15747 }
15748 arg1 = reinterpret_cast< wxGrid * >(argp1);
15749 ecode2 = SWIG_AsVal_int(obj1, &val2);
15750 if (!SWIG_IsOK(ecode2)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15752 }
15753 arg2 = static_cast< int >(val2);
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 resultobj = SWIG_From_int(static_cast< int >(result));
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = 0;
15769 wxGrid *arg1 = (wxGrid *) 0 ;
15770 int arg2 ;
15771 bool arg3 = (bool) true ;
15772 void *argp1 = 0 ;
15773 int res1 = 0 ;
15774 int val2 ;
15775 int ecode2 = 0 ;
15776 bool val3 ;
15777 int ecode3 = 0 ;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 PyObject * obj2 = 0 ;
15781 char * kwnames[] = {
15782 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15783 };
15784
15785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15789 }
15790 arg1 = reinterpret_cast< wxGrid * >(argp1);
15791 ecode2 = SWIG_AsVal_int(obj1, &val2);
15792 if (!SWIG_IsOK(ecode2)) {
15793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15794 }
15795 arg2 = static_cast< int >(val2);
15796 if (obj2) {
15797 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15798 if (!SWIG_IsOK(ecode3)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15800 }
15801 arg3 = static_cast< bool >(val3);
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 (arg1)->AutoSizeColumn(arg2,arg3);
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 resultobj = SWIG_Py_Void();
15810 return resultobj;
15811 fail:
15812 return NULL;
15813 }
15814
15815
15816 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15817 PyObject *resultobj = 0;
15818 wxGrid *arg1 = (wxGrid *) 0 ;
15819 int arg2 ;
15820 bool arg3 = (bool) true ;
15821 void *argp1 = 0 ;
15822 int res1 = 0 ;
15823 int val2 ;
15824 int ecode2 = 0 ;
15825 bool val3 ;
15826 int ecode3 = 0 ;
15827 PyObject * obj0 = 0 ;
15828 PyObject * obj1 = 0 ;
15829 PyObject * obj2 = 0 ;
15830 char * kwnames[] = {
15831 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15832 };
15833
15834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15836 if (!SWIG_IsOK(res1)) {
15837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15838 }
15839 arg1 = reinterpret_cast< wxGrid * >(argp1);
15840 ecode2 = SWIG_AsVal_int(obj1, &val2);
15841 if (!SWIG_IsOK(ecode2)) {
15842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15843 }
15844 arg2 = static_cast< int >(val2);
15845 if (obj2) {
15846 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15847 if (!SWIG_IsOK(ecode3)) {
15848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15849 }
15850 arg3 = static_cast< bool >(val3);
15851 }
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 (arg1)->AutoSizeRow(arg2,arg3);
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 resultobj = SWIG_Py_Void();
15859 return resultobj;
15860 fail:
15861 return NULL;
15862 }
15863
15864
15865 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15866 PyObject *resultobj = 0;
15867 wxGrid *arg1 = (wxGrid *) 0 ;
15868 bool arg2 = (bool) true ;
15869 void *argp1 = 0 ;
15870 int res1 = 0 ;
15871 bool val2 ;
15872 int ecode2 = 0 ;
15873 PyObject * obj0 = 0 ;
15874 PyObject * obj1 = 0 ;
15875 char * kwnames[] = {
15876 (char *) "self",(char *) "setAsMin", NULL
15877 };
15878
15879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15881 if (!SWIG_IsOK(res1)) {
15882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15883 }
15884 arg1 = reinterpret_cast< wxGrid * >(argp1);
15885 if (obj1) {
15886 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15887 if (!SWIG_IsOK(ecode2)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15889 }
15890 arg2 = static_cast< bool >(val2);
15891 }
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 (arg1)->AutoSizeColumns(arg2);
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_Py_Void();
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj = 0;
15907 wxGrid *arg1 = (wxGrid *) 0 ;
15908 bool arg2 = (bool) true ;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 bool val2 ;
15912 int ecode2 = 0 ;
15913 PyObject * obj0 = 0 ;
15914 PyObject * obj1 = 0 ;
15915 char * kwnames[] = {
15916 (char *) "self",(char *) "setAsMin", NULL
15917 };
15918
15919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15921 if (!SWIG_IsOK(res1)) {
15922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15923 }
15924 arg1 = reinterpret_cast< wxGrid * >(argp1);
15925 if (obj1) {
15926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15927 if (!SWIG_IsOK(ecode2)) {
15928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15929 }
15930 arg2 = static_cast< bool >(val2);
15931 }
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 (arg1)->AutoSizeRows(arg2);
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 resultobj = SWIG_Py_Void();
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15946 PyObject *resultobj = 0;
15947 wxGrid *arg1 = (wxGrid *) 0 ;
15948 void *argp1 = 0 ;
15949 int res1 = 0 ;
15950 PyObject *swig_obj[1] ;
15951
15952 if (!args) SWIG_fail;
15953 swig_obj[0] = args;
15954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15955 if (!SWIG_IsOK(res1)) {
15956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15957 }
15958 arg1 = reinterpret_cast< wxGrid * >(argp1);
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 (arg1)->AutoSize();
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 resultobj = SWIG_Py_Void();
15966 return resultobj;
15967 fail:
15968 return NULL;
15969 }
15970
15971
15972 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15973 PyObject *resultobj = 0;
15974 wxGrid *arg1 = (wxGrid *) 0 ;
15975 int arg2 ;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 int val2 ;
15979 int ecode2 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 char * kwnames[] = {
15983 (char *) "self",(char *) "row", NULL
15984 };
15985
15986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15990 }
15991 arg1 = reinterpret_cast< wxGrid * >(argp1);
15992 ecode2 = SWIG_AsVal_int(obj1, &val2);
15993 if (!SWIG_IsOK(ecode2)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15995 }
15996 arg2 = static_cast< int >(val2);
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->AutoSizeRowLabelSize(arg2);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16011 PyObject *resultobj = 0;
16012 wxGrid *arg1 = (wxGrid *) 0 ;
16013 int arg2 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 int val2 ;
16017 int ecode2 = 0 ;
16018 PyObject * obj0 = 0 ;
16019 PyObject * obj1 = 0 ;
16020 char * kwnames[] = {
16021 (char *) "self",(char *) "col", NULL
16022 };
16023
16024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16026 if (!SWIG_IsOK(res1)) {
16027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16028 }
16029 arg1 = reinterpret_cast< wxGrid * >(argp1);
16030 ecode2 = SWIG_AsVal_int(obj1, &val2);
16031 if (!SWIG_IsOK(ecode2)) {
16032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16033 }
16034 arg2 = static_cast< int >(val2);
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 (arg1)->AutoSizeColLabelSize(arg2);
16038 wxPyEndAllowThreads(__tstate);
16039 if (PyErr_Occurred()) SWIG_fail;
16040 }
16041 resultobj = SWIG_Py_Void();
16042 return resultobj;
16043 fail:
16044 return NULL;
16045 }
16046
16047
16048 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16049 PyObject *resultobj = 0;
16050 wxGrid *arg1 = (wxGrid *) 0 ;
16051 int arg2 ;
16052 int arg3 ;
16053 void *argp1 = 0 ;
16054 int res1 = 0 ;
16055 int val2 ;
16056 int ecode2 = 0 ;
16057 int val3 ;
16058 int ecode3 = 0 ;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 PyObject * obj2 = 0 ;
16062 char * kwnames[] = {
16063 (char *) "self",(char *) "col",(char *) "width", NULL
16064 };
16065
16066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16070 }
16071 arg1 = reinterpret_cast< wxGrid * >(argp1);
16072 ecode2 = SWIG_AsVal_int(obj1, &val2);
16073 if (!SWIG_IsOK(ecode2)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16075 }
16076 arg2 = static_cast< int >(val2);
16077 ecode3 = SWIG_AsVal_int(obj2, &val3);
16078 if (!SWIG_IsOK(ecode3)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16080 }
16081 arg3 = static_cast< int >(val3);
16082 {
16083 PyThreadState* __tstate = wxPyBeginAllowThreads();
16084 (arg1)->SetColMinimalWidth(arg2,arg3);
16085 wxPyEndAllowThreads(__tstate);
16086 if (PyErr_Occurred()) SWIG_fail;
16087 }
16088 resultobj = SWIG_Py_Void();
16089 return resultobj;
16090 fail:
16091 return NULL;
16092 }
16093
16094
16095 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj = 0;
16097 wxGrid *arg1 = (wxGrid *) 0 ;
16098 int arg2 ;
16099 int arg3 ;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 int val2 ;
16103 int ecode2 = 0 ;
16104 int val3 ;
16105 int ecode3 = 0 ;
16106 PyObject * obj0 = 0 ;
16107 PyObject * obj1 = 0 ;
16108 PyObject * obj2 = 0 ;
16109 char * kwnames[] = {
16110 (char *) "self",(char *) "row",(char *) "width", NULL
16111 };
16112
16113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16115 if (!SWIG_IsOK(res1)) {
16116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16117 }
16118 arg1 = reinterpret_cast< wxGrid * >(argp1);
16119 ecode2 = SWIG_AsVal_int(obj1, &val2);
16120 if (!SWIG_IsOK(ecode2)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16122 }
16123 arg2 = static_cast< int >(val2);
16124 ecode3 = SWIG_AsVal_int(obj2, &val3);
16125 if (!SWIG_IsOK(ecode3)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16127 }
16128 arg3 = static_cast< int >(val3);
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 (arg1)->SetRowMinimalHeight(arg2,arg3);
16132 wxPyEndAllowThreads(__tstate);
16133 if (PyErr_Occurred()) SWIG_fail;
16134 }
16135 resultobj = SWIG_Py_Void();
16136 return resultobj;
16137 fail:
16138 return NULL;
16139 }
16140
16141
16142 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16143 PyObject *resultobj = 0;
16144 wxGrid *arg1 = (wxGrid *) 0 ;
16145 int arg2 ;
16146 void *argp1 = 0 ;
16147 int res1 = 0 ;
16148 int val2 ;
16149 int ecode2 = 0 ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 char * kwnames[] = {
16153 (char *) "self",(char *) "width", NULL
16154 };
16155
16156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16158 if (!SWIG_IsOK(res1)) {
16159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16160 }
16161 arg1 = reinterpret_cast< wxGrid * >(argp1);
16162 ecode2 = SWIG_AsVal_int(obj1, &val2);
16163 if (!SWIG_IsOK(ecode2)) {
16164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16165 }
16166 arg2 = static_cast< int >(val2);
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 (arg1)->SetColMinimalAcceptableWidth(arg2);
16170 wxPyEndAllowThreads(__tstate);
16171 if (PyErr_Occurred()) SWIG_fail;
16172 }
16173 resultobj = SWIG_Py_Void();
16174 return resultobj;
16175 fail:
16176 return NULL;
16177 }
16178
16179
16180 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16181 PyObject *resultobj = 0;
16182 wxGrid *arg1 = (wxGrid *) 0 ;
16183 int arg2 ;
16184 void *argp1 = 0 ;
16185 int res1 = 0 ;
16186 int val2 ;
16187 int ecode2 = 0 ;
16188 PyObject * obj0 = 0 ;
16189 PyObject * obj1 = 0 ;
16190 char * kwnames[] = {
16191 (char *) "self",(char *) "width", NULL
16192 };
16193
16194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16196 if (!SWIG_IsOK(res1)) {
16197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16198 }
16199 arg1 = reinterpret_cast< wxGrid * >(argp1);
16200 ecode2 = SWIG_AsVal_int(obj1, &val2);
16201 if (!SWIG_IsOK(ecode2)) {
16202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16203 }
16204 arg2 = static_cast< int >(val2);
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 resultobj = SWIG_Py_Void();
16212 return resultobj;
16213 fail:
16214 return NULL;
16215 }
16216
16217
16218 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16219 PyObject *resultobj = 0;
16220 wxGrid *arg1 = (wxGrid *) 0 ;
16221 int result;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 PyObject *swig_obj[1] ;
16225
16226 if (!args) SWIG_fail;
16227 swig_obj[0] = args;
16228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16229 if (!SWIG_IsOK(res1)) {
16230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16231 }
16232 arg1 = reinterpret_cast< wxGrid * >(argp1);
16233 {
16234 PyThreadState* __tstate = wxPyBeginAllowThreads();
16235 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 resultobj = SWIG_From_int(static_cast< int >(result));
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16247 PyObject *resultobj = 0;
16248 wxGrid *arg1 = (wxGrid *) 0 ;
16249 int result;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 PyObject *swig_obj[1] ;
16253
16254 if (!args) SWIG_fail;
16255 swig_obj[0] = args;
16256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16257 if (!SWIG_IsOK(res1)) {
16258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16259 }
16260 arg1 = reinterpret_cast< wxGrid * >(argp1);
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 resultobj = SWIG_From_int(static_cast< int >(result));
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxGrid *arg1 = (wxGrid *) 0 ;
16277 wxColour *arg2 = 0 ;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 wxColour temp2 ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *)"arg2", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16291 }
16292 arg1 = reinterpret_cast< wxGrid * >(argp1);
16293 {
16294 arg2 = &temp2;
16295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16296 }
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 resultobj = SWIG_Py_Void();
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj = 0;
16312 wxGrid *arg1 = (wxGrid *) 0 ;
16313 int arg2 ;
16314 int arg3 ;
16315 wxColour *arg4 = 0 ;
16316 void *argp1 = 0 ;
16317 int res1 = 0 ;
16318 int val2 ;
16319 int ecode2 = 0 ;
16320 int val3 ;
16321 int ecode3 = 0 ;
16322 wxColour temp4 ;
16323 PyObject * obj0 = 0 ;
16324 PyObject * obj1 = 0 ;
16325 PyObject * obj2 = 0 ;
16326 PyObject * obj3 = 0 ;
16327 char * kwnames[] = {
16328 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16329 };
16330
16331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16333 if (!SWIG_IsOK(res1)) {
16334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16335 }
16336 arg1 = reinterpret_cast< wxGrid * >(argp1);
16337 ecode2 = SWIG_AsVal_int(obj1, &val2);
16338 if (!SWIG_IsOK(ecode2)) {
16339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16340 }
16341 arg2 = static_cast< int >(val2);
16342 ecode3 = SWIG_AsVal_int(obj2, &val3);
16343 if (!SWIG_IsOK(ecode3)) {
16344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16345 }
16346 arg3 = static_cast< int >(val3);
16347 {
16348 arg4 = &temp4;
16349 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_Py_Void();
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj = 0;
16366 wxGrid *arg1 = (wxGrid *) 0 ;
16367 wxColour *arg2 = 0 ;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 wxColour temp2 ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 char * kwnames[] = {
16374 (char *) "self",(char *)"arg2", NULL
16375 };
16376
16377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16379 if (!SWIG_IsOK(res1)) {
16380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16381 }
16382 arg1 = reinterpret_cast< wxGrid * >(argp1);
16383 {
16384 arg2 = &temp2;
16385 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16386 }
16387 {
16388 PyThreadState* __tstate = wxPyBeginAllowThreads();
16389 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16390 wxPyEndAllowThreads(__tstate);
16391 if (PyErr_Occurred()) SWIG_fail;
16392 }
16393 resultobj = SWIG_Py_Void();
16394 return resultobj;
16395 fail:
16396 return NULL;
16397 }
16398
16399
16400 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16401 PyObject *resultobj = 0;
16402 wxGrid *arg1 = (wxGrid *) 0 ;
16403 int arg2 ;
16404 int arg3 ;
16405 wxColour *arg4 = 0 ;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 int val2 ;
16409 int ecode2 = 0 ;
16410 int val3 ;
16411 int ecode3 = 0 ;
16412 wxColour temp4 ;
16413 PyObject * obj0 = 0 ;
16414 PyObject * obj1 = 0 ;
16415 PyObject * obj2 = 0 ;
16416 PyObject * obj3 = 0 ;
16417 char * kwnames[] = {
16418 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16419 };
16420
16421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16423 if (!SWIG_IsOK(res1)) {
16424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16425 }
16426 arg1 = reinterpret_cast< wxGrid * >(argp1);
16427 ecode2 = SWIG_AsVal_int(obj1, &val2);
16428 if (!SWIG_IsOK(ecode2)) {
16429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16430 }
16431 arg2 = static_cast< int >(val2);
16432 ecode3 = SWIG_AsVal_int(obj2, &val3);
16433 if (!SWIG_IsOK(ecode3)) {
16434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16435 }
16436 arg3 = static_cast< int >(val3);
16437 {
16438 arg4 = &temp4;
16439 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16440 }
16441 {
16442 PyThreadState* __tstate = wxPyBeginAllowThreads();
16443 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16444 wxPyEndAllowThreads(__tstate);
16445 if (PyErr_Occurred()) SWIG_fail;
16446 }
16447 resultobj = SWIG_Py_Void();
16448 return resultobj;
16449 fail:
16450 return NULL;
16451 }
16452
16453
16454 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16455 PyObject *resultobj = 0;
16456 wxGrid *arg1 = (wxGrid *) 0 ;
16457 wxFont *arg2 = 0 ;
16458 void *argp1 = 0 ;
16459 int res1 = 0 ;
16460 void *argp2 = 0 ;
16461 int res2 = 0 ;
16462 PyObject * obj0 = 0 ;
16463 PyObject * obj1 = 0 ;
16464 char * kwnames[] = {
16465 (char *) "self",(char *)"arg2", NULL
16466 };
16467
16468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16470 if (!SWIG_IsOK(res1)) {
16471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16472 }
16473 arg1 = reinterpret_cast< wxGrid * >(argp1);
16474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16475 if (!SWIG_IsOK(res2)) {
16476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16477 }
16478 if (!argp2) {
16479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16480 }
16481 arg2 = reinterpret_cast< wxFont * >(argp2);
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 resultobj = SWIG_Py_Void();
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj = 0;
16497 wxGrid *arg1 = (wxGrid *) 0 ;
16498 int arg2 ;
16499 int arg3 ;
16500 wxFont *arg4 = 0 ;
16501 void *argp1 = 0 ;
16502 int res1 = 0 ;
16503 int val2 ;
16504 int ecode2 = 0 ;
16505 int val3 ;
16506 int ecode3 = 0 ;
16507 void *argp4 = 0 ;
16508 int res4 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 PyObject * obj1 = 0 ;
16511 PyObject * obj2 = 0 ;
16512 PyObject * obj3 = 0 ;
16513 char * kwnames[] = {
16514 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16515 };
16516
16517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16519 if (!SWIG_IsOK(res1)) {
16520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16521 }
16522 arg1 = reinterpret_cast< wxGrid * >(argp1);
16523 ecode2 = SWIG_AsVal_int(obj1, &val2);
16524 if (!SWIG_IsOK(ecode2)) {
16525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16526 }
16527 arg2 = static_cast< int >(val2);
16528 ecode3 = SWIG_AsVal_int(obj2, &val3);
16529 if (!SWIG_IsOK(ecode3)) {
16530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16531 }
16532 arg3 = static_cast< int >(val3);
16533 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16534 if (!SWIG_IsOK(res4)) {
16535 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16536 }
16537 if (!argp4) {
16538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16539 }
16540 arg4 = reinterpret_cast< wxFont * >(argp4);
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 resultobj = SWIG_Py_Void();
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16555 PyObject *resultobj = 0;
16556 wxGrid *arg1 = (wxGrid *) 0 ;
16557 int arg2 ;
16558 int arg3 ;
16559 void *argp1 = 0 ;
16560 int res1 = 0 ;
16561 int val2 ;
16562 int ecode2 = 0 ;
16563 int val3 ;
16564 int ecode3 = 0 ;
16565 PyObject * obj0 = 0 ;
16566 PyObject * obj1 = 0 ;
16567 PyObject * obj2 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16576 }
16577 arg1 = reinterpret_cast< wxGrid * >(argp1);
16578 ecode2 = SWIG_AsVal_int(obj1, &val2);
16579 if (!SWIG_IsOK(ecode2)) {
16580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16581 }
16582 arg2 = static_cast< int >(val2);
16583 ecode3 = SWIG_AsVal_int(obj2, &val3);
16584 if (!SWIG_IsOK(ecode3)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16586 }
16587 arg3 = static_cast< int >(val3);
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 resultobj = SWIG_Py_Void();
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16602 PyObject *resultobj = 0;
16603 wxGrid *arg1 = (wxGrid *) 0 ;
16604 int arg2 ;
16605 int arg3 ;
16606 int arg4 ;
16607 int arg5 ;
16608 void *argp1 = 0 ;
16609 int res1 = 0 ;
16610 int val2 ;
16611 int ecode2 = 0 ;
16612 int val3 ;
16613 int ecode3 = 0 ;
16614 int val4 ;
16615 int ecode4 = 0 ;
16616 int val5 ;
16617 int ecode5 = 0 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 PyObject * obj2 = 0 ;
16621 PyObject * obj3 = 0 ;
16622 PyObject * obj4 = 0 ;
16623 char * kwnames[] = {
16624 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16625 };
16626
16627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16629 if (!SWIG_IsOK(res1)) {
16630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16631 }
16632 arg1 = reinterpret_cast< wxGrid * >(argp1);
16633 ecode2 = SWIG_AsVal_int(obj1, &val2);
16634 if (!SWIG_IsOK(ecode2)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16636 }
16637 arg2 = static_cast< int >(val2);
16638 ecode3 = SWIG_AsVal_int(obj2, &val3);
16639 if (!SWIG_IsOK(ecode3)) {
16640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16641 }
16642 arg3 = static_cast< int >(val3);
16643 ecode4 = SWIG_AsVal_int(obj3, &val4);
16644 if (!SWIG_IsOK(ecode4)) {
16645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16646 }
16647 arg4 = static_cast< int >(val4);
16648 ecode5 = SWIG_AsVal_int(obj4, &val5);
16649 if (!SWIG_IsOK(ecode5)) {
16650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16651 }
16652 arg5 = static_cast< int >(val5);
16653 {
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_Py_Void();
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj = 0;
16668 wxGrid *arg1 = (wxGrid *) 0 ;
16669 bool arg2 ;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 bool val2 ;
16673 int ecode2 = 0 ;
16674 PyObject * obj0 = 0 ;
16675 PyObject * obj1 = 0 ;
16676 char * kwnames[] = {
16677 (char *) "self",(char *) "allow", NULL
16678 };
16679
16680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16684 }
16685 arg1 = reinterpret_cast< wxGrid * >(argp1);
16686 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16687 if (!SWIG_IsOK(ecode2)) {
16688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16689 }
16690 arg2 = static_cast< bool >(val2);
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 (arg1)->SetDefaultCellOverflow(arg2);
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_Py_Void();
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj = 0;
16706 wxGrid *arg1 = (wxGrid *) 0 ;
16707 int arg2 ;
16708 int arg3 ;
16709 bool arg4 ;
16710 void *argp1 = 0 ;
16711 int res1 = 0 ;
16712 int val2 ;
16713 int ecode2 = 0 ;
16714 int val3 ;
16715 int ecode3 = 0 ;
16716 bool val4 ;
16717 int ecode4 = 0 ;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 PyObject * obj2 = 0 ;
16721 PyObject * obj3 = 0 ;
16722 char * kwnames[] = {
16723 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16724 };
16725
16726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16730 }
16731 arg1 = reinterpret_cast< wxGrid * >(argp1);
16732 ecode2 = SWIG_AsVal_int(obj1, &val2);
16733 if (!SWIG_IsOK(ecode2)) {
16734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16735 }
16736 arg2 = static_cast< int >(val2);
16737 ecode3 = SWIG_AsVal_int(obj2, &val3);
16738 if (!SWIG_IsOK(ecode3)) {
16739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16740 }
16741 arg3 = static_cast< int >(val3);
16742 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16743 if (!SWIG_IsOK(ecode4)) {
16744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16745 }
16746 arg4 = static_cast< bool >(val4);
16747 {
16748 PyThreadState* __tstate = wxPyBeginAllowThreads();
16749 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 resultobj = SWIG_Py_Void();
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj = 0;
16762 wxGrid *arg1 = (wxGrid *) 0 ;
16763 int arg2 ;
16764 int arg3 ;
16765 int arg4 ;
16766 int arg5 ;
16767 void *argp1 = 0 ;
16768 int res1 = 0 ;
16769 int val2 ;
16770 int ecode2 = 0 ;
16771 int val3 ;
16772 int ecode3 = 0 ;
16773 int val4 ;
16774 int ecode4 = 0 ;
16775 int val5 ;
16776 int ecode5 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 PyObject * obj1 = 0 ;
16779 PyObject * obj2 = 0 ;
16780 PyObject * obj3 = 0 ;
16781 PyObject * obj4 = 0 ;
16782 char * kwnames[] = {
16783 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16784 };
16785
16786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16788 if (!SWIG_IsOK(res1)) {
16789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16790 }
16791 arg1 = reinterpret_cast< wxGrid * >(argp1);
16792 ecode2 = SWIG_AsVal_int(obj1, &val2);
16793 if (!SWIG_IsOK(ecode2)) {
16794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16795 }
16796 arg2 = static_cast< int >(val2);
16797 ecode3 = SWIG_AsVal_int(obj2, &val3);
16798 if (!SWIG_IsOK(ecode3)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16800 }
16801 arg3 = static_cast< int >(val3);
16802 ecode4 = SWIG_AsVal_int(obj3, &val4);
16803 if (!SWIG_IsOK(ecode4)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16805 }
16806 arg4 = static_cast< int >(val4);
16807 ecode5 = SWIG_AsVal_int(obj4, &val5);
16808 if (!SWIG_IsOK(ecode5)) {
16809 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16810 }
16811 arg5 = static_cast< int >(val5);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 resultobj = SWIG_Py_Void();
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj = 0;
16827 wxGrid *arg1 = (wxGrid *) 0 ;
16828 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16829 void *argp1 = 0 ;
16830 int res1 = 0 ;
16831 void *argp2 = 0 ;
16832 int res2 = 0 ;
16833 PyObject * obj0 = 0 ;
16834 PyObject * obj1 = 0 ;
16835 char * kwnames[] = {
16836 (char *) "self",(char *) "renderer", NULL
16837 };
16838
16839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) 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_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16843 }
16844 arg1 = reinterpret_cast< wxGrid * >(argp1);
16845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16846 if (!SWIG_IsOK(res2)) {
16847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16848 }
16849 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 (arg1)->SetDefaultRenderer(arg2);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_Py_Void();
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxGrid *arg1 = (wxGrid *) 0 ;
16866 int arg2 ;
16867 int arg3 ;
16868 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16869 void *argp1 = 0 ;
16870 int res1 = 0 ;
16871 int val2 ;
16872 int ecode2 = 0 ;
16873 int val3 ;
16874 int ecode3 = 0 ;
16875 void *argp4 = 0 ;
16876 int res4 = 0 ;
16877 PyObject * obj0 = 0 ;
16878 PyObject * obj1 = 0 ;
16879 PyObject * obj2 = 0 ;
16880 PyObject * obj3 = 0 ;
16881 char * kwnames[] = {
16882 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16883 };
16884
16885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16887 if (!SWIG_IsOK(res1)) {
16888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16889 }
16890 arg1 = reinterpret_cast< wxGrid * >(argp1);
16891 ecode2 = SWIG_AsVal_int(obj1, &val2);
16892 if (!SWIG_IsOK(ecode2)) {
16893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16894 }
16895 arg2 = static_cast< int >(val2);
16896 ecode3 = SWIG_AsVal_int(obj2, &val3);
16897 if (!SWIG_IsOK(ecode3)) {
16898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16899 }
16900 arg3 = static_cast< int >(val3);
16901 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16902 if (!SWIG_IsOK(res4)) {
16903 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16904 }
16905 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = SWIG_Py_Void();
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16920 PyObject *resultobj = 0;
16921 wxGrid *arg1 = (wxGrid *) 0 ;
16922 wxGridCellRenderer *result = 0 ;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 PyObject *swig_obj[1] ;
16926
16927 if (!args) SWIG_fail;
16928 swig_obj[0] = args;
16929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16930 if (!SWIG_IsOK(res1)) {
16931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16932 }
16933 arg1 = reinterpret_cast< wxGrid * >(argp1);
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 {
16941 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj = 0;
16951 wxGrid *arg1 = (wxGrid *) 0 ;
16952 int arg2 ;
16953 int arg3 ;
16954 wxGridCellRenderer *result = 0 ;
16955 void *argp1 = 0 ;
16956 int res1 = 0 ;
16957 int val2 ;
16958 int ecode2 = 0 ;
16959 int val3 ;
16960 int ecode3 = 0 ;
16961 PyObject * obj0 = 0 ;
16962 PyObject * obj1 = 0 ;
16963 PyObject * obj2 = 0 ;
16964 char * kwnames[] = {
16965 (char *) "self",(char *) "row",(char *) "col", NULL
16966 };
16967
16968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16972 }
16973 arg1 = reinterpret_cast< wxGrid * >(argp1);
16974 ecode2 = SWIG_AsVal_int(obj1, &val2);
16975 if (!SWIG_IsOK(ecode2)) {
16976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16977 }
16978 arg2 = static_cast< int >(val2);
16979 ecode3 = SWIG_AsVal_int(obj2, &val3);
16980 if (!SWIG_IsOK(ecode3)) {
16981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16982 }
16983 arg3 = static_cast< int >(val3);
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 {
16991 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16992 }
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj = 0;
17001 wxGrid *arg1 = (wxGrid *) 0 ;
17002 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17003 void *argp1 = 0 ;
17004 int res1 = 0 ;
17005 void *argp2 = 0 ;
17006 int res2 = 0 ;
17007 PyObject * obj0 = 0 ;
17008 PyObject * obj1 = 0 ;
17009 char * kwnames[] = {
17010 (char *) "self",(char *) "editor", NULL
17011 };
17012
17013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17015 if (!SWIG_IsOK(res1)) {
17016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17017 }
17018 arg1 = reinterpret_cast< wxGrid * >(argp1);
17019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17020 if (!SWIG_IsOK(res2)) {
17021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17022 }
17023 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17024 {
17025 PyThreadState* __tstate = wxPyBeginAllowThreads();
17026 (arg1)->SetDefaultEditor(arg2);
17027 wxPyEndAllowThreads(__tstate);
17028 if (PyErr_Occurred()) SWIG_fail;
17029 }
17030 resultobj = SWIG_Py_Void();
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj = 0;
17039 wxGrid *arg1 = (wxGrid *) 0 ;
17040 int arg2 ;
17041 int arg3 ;
17042 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17043 void *argp1 = 0 ;
17044 int res1 = 0 ;
17045 int val2 ;
17046 int ecode2 = 0 ;
17047 int val3 ;
17048 int ecode3 = 0 ;
17049 void *argp4 = 0 ;
17050 int res4 = 0 ;
17051 PyObject * obj0 = 0 ;
17052 PyObject * obj1 = 0 ;
17053 PyObject * obj2 = 0 ;
17054 PyObject * obj3 = 0 ;
17055 char * kwnames[] = {
17056 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17057 };
17058
17059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17063 }
17064 arg1 = reinterpret_cast< wxGrid * >(argp1);
17065 ecode2 = SWIG_AsVal_int(obj1, &val2);
17066 if (!SWIG_IsOK(ecode2)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17068 }
17069 arg2 = static_cast< int >(val2);
17070 ecode3 = SWIG_AsVal_int(obj2, &val3);
17071 if (!SWIG_IsOK(ecode3)) {
17072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17073 }
17074 arg3 = static_cast< int >(val3);
17075 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17076 if (!SWIG_IsOK(res4)) {
17077 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17078 }
17079 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 (arg1)->SetCellEditor(arg2,arg3,arg4);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 resultobj = SWIG_Py_Void();
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17094 PyObject *resultobj = 0;
17095 wxGrid *arg1 = (wxGrid *) 0 ;
17096 wxGridCellEditor *result = 0 ;
17097 void *argp1 = 0 ;
17098 int res1 = 0 ;
17099 PyObject *swig_obj[1] ;
17100
17101 if (!args) SWIG_fail;
17102 swig_obj[0] = args;
17103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17104 if (!SWIG_IsOK(res1)) {
17105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17106 }
17107 arg1 = reinterpret_cast< wxGrid * >(argp1);
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17111 wxPyEndAllowThreads(__tstate);
17112 if (PyErr_Occurred()) SWIG_fail;
17113 }
17114 {
17115 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17116 }
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = 0;
17125 wxGrid *arg1 = (wxGrid *) 0 ;
17126 int arg2 ;
17127 int arg3 ;
17128 wxGridCellEditor *result = 0 ;
17129 void *argp1 = 0 ;
17130 int res1 = 0 ;
17131 int val2 ;
17132 int ecode2 = 0 ;
17133 int val3 ;
17134 int ecode3 = 0 ;
17135 PyObject * obj0 = 0 ;
17136 PyObject * obj1 = 0 ;
17137 PyObject * obj2 = 0 ;
17138 char * kwnames[] = {
17139 (char *) "self",(char *) "row",(char *) "col", NULL
17140 };
17141
17142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17144 if (!SWIG_IsOK(res1)) {
17145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17146 }
17147 arg1 = reinterpret_cast< wxGrid * >(argp1);
17148 ecode2 = SWIG_AsVal_int(obj1, &val2);
17149 if (!SWIG_IsOK(ecode2)) {
17150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17151 }
17152 arg2 = static_cast< int >(val2);
17153 ecode3 = SWIG_AsVal_int(obj2, &val3);
17154 if (!SWIG_IsOK(ecode3)) {
17155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17156 }
17157 arg3 = static_cast< int >(val3);
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17161 wxPyEndAllowThreads(__tstate);
17162 if (PyErr_Occurred()) SWIG_fail;
17163 }
17164 {
17165 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17166 }
17167 return resultobj;
17168 fail:
17169 return NULL;
17170 }
17171
17172
17173 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17174 PyObject *resultobj = 0;
17175 wxGrid *arg1 = (wxGrid *) 0 ;
17176 int arg2 ;
17177 int arg3 ;
17178 wxString result;
17179 void *argp1 = 0 ;
17180 int res1 = 0 ;
17181 int val2 ;
17182 int ecode2 = 0 ;
17183 int val3 ;
17184 int ecode3 = 0 ;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 PyObject * obj2 = 0 ;
17188 char * kwnames[] = {
17189 (char *) "self",(char *) "row",(char *) "col", NULL
17190 };
17191
17192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17194 if (!SWIG_IsOK(res1)) {
17195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17196 }
17197 arg1 = reinterpret_cast< wxGrid * >(argp1);
17198 ecode2 = SWIG_AsVal_int(obj1, &val2);
17199 if (!SWIG_IsOK(ecode2)) {
17200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17201 }
17202 arg2 = static_cast< int >(val2);
17203 ecode3 = SWIG_AsVal_int(obj2, &val3);
17204 if (!SWIG_IsOK(ecode3)) {
17205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17206 }
17207 arg3 = static_cast< int >(val3);
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 result = (arg1)->GetCellValue(arg2,arg3);
17211 wxPyEndAllowThreads(__tstate);
17212 if (PyErr_Occurred()) SWIG_fail;
17213 }
17214 {
17215 #if wxUSE_UNICODE
17216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17217 #else
17218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17219 #endif
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = 0;
17229 wxGrid *arg1 = (wxGrid *) 0 ;
17230 int arg2 ;
17231 int arg3 ;
17232 wxString *arg4 = 0 ;
17233 void *argp1 = 0 ;
17234 int res1 = 0 ;
17235 int val2 ;
17236 int ecode2 = 0 ;
17237 int val3 ;
17238 int ecode3 = 0 ;
17239 bool temp4 = false ;
17240 PyObject * obj0 = 0 ;
17241 PyObject * obj1 = 0 ;
17242 PyObject * obj2 = 0 ;
17243 PyObject * obj3 = 0 ;
17244 char * kwnames[] = {
17245 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17246 };
17247
17248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17250 if (!SWIG_IsOK(res1)) {
17251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17252 }
17253 arg1 = reinterpret_cast< wxGrid * >(argp1);
17254 ecode2 = SWIG_AsVal_int(obj1, &val2);
17255 if (!SWIG_IsOK(ecode2)) {
17256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17257 }
17258 arg2 = static_cast< int >(val2);
17259 ecode3 = SWIG_AsVal_int(obj2, &val3);
17260 if (!SWIG_IsOK(ecode3)) {
17261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17262 }
17263 arg3 = static_cast< int >(val3);
17264 {
17265 arg4 = wxString_in_helper(obj3);
17266 if (arg4 == NULL) SWIG_fail;
17267 temp4 = true;
17268 }
17269 {
17270 PyThreadState* __tstate = wxPyBeginAllowThreads();
17271 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 resultobj = SWIG_Py_Void();
17276 {
17277 if (temp4)
17278 delete arg4;
17279 }
17280 return resultobj;
17281 fail:
17282 {
17283 if (temp4)
17284 delete arg4;
17285 }
17286 return NULL;
17287 }
17288
17289
17290 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17291 PyObject *resultobj = 0;
17292 wxGrid *arg1 = (wxGrid *) 0 ;
17293 int arg2 ;
17294 int arg3 ;
17295 bool result;
17296 void *argp1 = 0 ;
17297 int res1 = 0 ;
17298 int val2 ;
17299 int ecode2 = 0 ;
17300 int val3 ;
17301 int ecode3 = 0 ;
17302 PyObject * obj0 = 0 ;
17303 PyObject * obj1 = 0 ;
17304 PyObject * obj2 = 0 ;
17305 char * kwnames[] = {
17306 (char *) "self",(char *) "row",(char *) "col", NULL
17307 };
17308
17309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17311 if (!SWIG_IsOK(res1)) {
17312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17313 }
17314 arg1 = reinterpret_cast< wxGrid * >(argp1);
17315 ecode2 = SWIG_AsVal_int(obj1, &val2);
17316 if (!SWIG_IsOK(ecode2)) {
17317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17318 }
17319 arg2 = static_cast< int >(val2);
17320 ecode3 = SWIG_AsVal_int(obj2, &val3);
17321 if (!SWIG_IsOK(ecode3)) {
17322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17323 }
17324 arg3 = static_cast< int >(val3);
17325 {
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 {
17332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17333 }
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17341 PyObject *resultobj = 0;
17342 wxGrid *arg1 = (wxGrid *) 0 ;
17343 int arg2 ;
17344 int arg3 ;
17345 bool arg4 = (bool) true ;
17346 void *argp1 = 0 ;
17347 int res1 = 0 ;
17348 int val2 ;
17349 int ecode2 = 0 ;
17350 int val3 ;
17351 int ecode3 = 0 ;
17352 bool val4 ;
17353 int ecode4 = 0 ;
17354 PyObject * obj0 = 0 ;
17355 PyObject * obj1 = 0 ;
17356 PyObject * obj2 = 0 ;
17357 PyObject * obj3 = 0 ;
17358 char * kwnames[] = {
17359 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17360 };
17361
17362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17364 if (!SWIG_IsOK(res1)) {
17365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17366 }
17367 arg1 = reinterpret_cast< wxGrid * >(argp1);
17368 ecode2 = SWIG_AsVal_int(obj1, &val2);
17369 if (!SWIG_IsOK(ecode2)) {
17370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17371 }
17372 arg2 = static_cast< int >(val2);
17373 ecode3 = SWIG_AsVal_int(obj2, &val3);
17374 if (!SWIG_IsOK(ecode3)) {
17375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17376 }
17377 arg3 = static_cast< int >(val3);
17378 if (obj3) {
17379 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17380 if (!SWIG_IsOK(ecode4)) {
17381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17382 }
17383 arg4 = static_cast< bool >(val4);
17384 }
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 (arg1)->SetReadOnly(arg2,arg3,arg4);
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_Py_Void();
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17399 PyObject *resultobj = 0;
17400 wxGrid *arg1 = (wxGrid *) 0 ;
17401 int arg2 ;
17402 bool arg3 = (bool) false ;
17403 void *argp1 = 0 ;
17404 int res1 = 0 ;
17405 int val2 ;
17406 int ecode2 = 0 ;
17407 bool val3 ;
17408 int ecode3 = 0 ;
17409 PyObject * obj0 = 0 ;
17410 PyObject * obj1 = 0 ;
17411 PyObject * obj2 = 0 ;
17412 char * kwnames[] = {
17413 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17414 };
17415
17416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17418 if (!SWIG_IsOK(res1)) {
17419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17420 }
17421 arg1 = reinterpret_cast< wxGrid * >(argp1);
17422 ecode2 = SWIG_AsVal_int(obj1, &val2);
17423 if (!SWIG_IsOK(ecode2)) {
17424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17425 }
17426 arg2 = static_cast< int >(val2);
17427 if (obj2) {
17428 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17429 if (!SWIG_IsOK(ecode3)) {
17430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17431 }
17432 arg3 = static_cast< bool >(val3);
17433 }
17434 {
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 (arg1)->SelectRow(arg2,arg3);
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 resultobj = SWIG_Py_Void();
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj = 0;
17449 wxGrid *arg1 = (wxGrid *) 0 ;
17450 int arg2 ;
17451 bool arg3 = (bool) false ;
17452 void *argp1 = 0 ;
17453 int res1 = 0 ;
17454 int val2 ;
17455 int ecode2 = 0 ;
17456 bool val3 ;
17457 int ecode3 = 0 ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 char * kwnames[] = {
17462 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17463 };
17464
17465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17467 if (!SWIG_IsOK(res1)) {
17468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17469 }
17470 arg1 = reinterpret_cast< wxGrid * >(argp1);
17471 ecode2 = SWIG_AsVal_int(obj1, &val2);
17472 if (!SWIG_IsOK(ecode2)) {
17473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17474 }
17475 arg2 = static_cast< int >(val2);
17476 if (obj2) {
17477 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17478 if (!SWIG_IsOK(ecode3)) {
17479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17480 }
17481 arg3 = static_cast< bool >(val3);
17482 }
17483 {
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 (arg1)->SelectCol(arg2,arg3);
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 resultobj = SWIG_Py_Void();
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj = 0;
17498 wxGrid *arg1 = (wxGrid *) 0 ;
17499 int arg2 ;
17500 int arg3 ;
17501 int arg4 ;
17502 int arg5 ;
17503 bool arg6 = (bool) false ;
17504 void *argp1 = 0 ;
17505 int res1 = 0 ;
17506 int val2 ;
17507 int ecode2 = 0 ;
17508 int val3 ;
17509 int ecode3 = 0 ;
17510 int val4 ;
17511 int ecode4 = 0 ;
17512 int val5 ;
17513 int ecode5 = 0 ;
17514 bool val6 ;
17515 int ecode6 = 0 ;
17516 PyObject * obj0 = 0 ;
17517 PyObject * obj1 = 0 ;
17518 PyObject * obj2 = 0 ;
17519 PyObject * obj3 = 0 ;
17520 PyObject * obj4 = 0 ;
17521 PyObject * obj5 = 0 ;
17522 char * kwnames[] = {
17523 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17524 };
17525
17526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17528 if (!SWIG_IsOK(res1)) {
17529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17530 }
17531 arg1 = reinterpret_cast< wxGrid * >(argp1);
17532 ecode2 = SWIG_AsVal_int(obj1, &val2);
17533 if (!SWIG_IsOK(ecode2)) {
17534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17535 }
17536 arg2 = static_cast< int >(val2);
17537 ecode3 = SWIG_AsVal_int(obj2, &val3);
17538 if (!SWIG_IsOK(ecode3)) {
17539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17540 }
17541 arg3 = static_cast< int >(val3);
17542 ecode4 = SWIG_AsVal_int(obj3, &val4);
17543 if (!SWIG_IsOK(ecode4)) {
17544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17545 }
17546 arg4 = static_cast< int >(val4);
17547 ecode5 = SWIG_AsVal_int(obj4, &val5);
17548 if (!SWIG_IsOK(ecode5)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17550 }
17551 arg5 = static_cast< int >(val5);
17552 if (obj5) {
17553 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17554 if (!SWIG_IsOK(ecode6)) {
17555 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17556 }
17557 arg6 = static_cast< bool >(val6);
17558 }
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_Py_Void();
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *resultobj = 0;
17574 wxGrid *arg1 = (wxGrid *) 0 ;
17575 void *argp1 = 0 ;
17576 int res1 = 0 ;
17577 PyObject *swig_obj[1] ;
17578
17579 if (!args) SWIG_fail;
17580 swig_obj[0] = args;
17581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17582 if (!SWIG_IsOK(res1)) {
17583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17584 }
17585 arg1 = reinterpret_cast< wxGrid * >(argp1);
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 (arg1)->SelectAll();
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 resultobj = SWIG_Py_Void();
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17600 PyObject *resultobj = 0;
17601 wxGrid *arg1 = (wxGrid *) 0 ;
17602 bool result;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 PyObject *swig_obj[1] ;
17606
17607 if (!args) SWIG_fail;
17608 swig_obj[0] = args;
17609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17610 if (!SWIG_IsOK(res1)) {
17611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17612 }
17613 arg1 = reinterpret_cast< wxGrid * >(argp1);
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (bool)(arg1)->IsSelection();
17617 wxPyEndAllowThreads(__tstate);
17618 if (PyErr_Occurred()) SWIG_fail;
17619 }
17620 {
17621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17622 }
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *resultobj = 0;
17631 wxGrid *arg1 = (wxGrid *) 0 ;
17632 void *argp1 = 0 ;
17633 int res1 = 0 ;
17634 PyObject *swig_obj[1] ;
17635
17636 if (!args) SWIG_fail;
17637 swig_obj[0] = args;
17638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17639 if (!SWIG_IsOK(res1)) {
17640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17641 }
17642 arg1 = reinterpret_cast< wxGrid * >(argp1);
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 (arg1)->ClearSelection();
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 resultobj = SWIG_Py_Void();
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj = 0;
17658 wxGrid *arg1 = (wxGrid *) 0 ;
17659 int arg2 ;
17660 int arg3 ;
17661 bool result;
17662 void *argp1 = 0 ;
17663 int res1 = 0 ;
17664 int val2 ;
17665 int ecode2 = 0 ;
17666 int val3 ;
17667 int ecode3 = 0 ;
17668 PyObject * obj0 = 0 ;
17669 PyObject * obj1 = 0 ;
17670 PyObject * obj2 = 0 ;
17671 char * kwnames[] = {
17672 (char *) "self",(char *) "row",(char *) "col", NULL
17673 };
17674
17675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17677 if (!SWIG_IsOK(res1)) {
17678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17679 }
17680 arg1 = reinterpret_cast< wxGrid * >(argp1);
17681 ecode2 = SWIG_AsVal_int(obj1, &val2);
17682 if (!SWIG_IsOK(ecode2)) {
17683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17684 }
17685 arg2 = static_cast< int >(val2);
17686 ecode3 = SWIG_AsVal_int(obj2, &val3);
17687 if (!SWIG_IsOK(ecode3)) {
17688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17689 }
17690 arg3 = static_cast< int >(val3);
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17694 wxPyEndAllowThreads(__tstate);
17695 if (PyErr_Occurred()) SWIG_fail;
17696 }
17697 {
17698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17699 }
17700 return resultobj;
17701 fail:
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxGrid *arg1 = (wxGrid *) 0 ;
17709 wxGridCellCoordsArray result;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 PyObject *swig_obj[1] ;
17713
17714 if (!args) SWIG_fail;
17715 swig_obj[0] = args;
17716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17717 if (!SWIG_IsOK(res1)) {
17718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17719 }
17720 arg1 = reinterpret_cast< wxGrid * >(argp1);
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = ((wxGrid const *)arg1)->GetSelectedCells();
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 {
17728 resultobj = wxGridCellCoordsArray_helper(result);
17729 }
17730 return resultobj;
17731 fail:
17732 return NULL;
17733 }
17734
17735
17736 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxGrid *arg1 = (wxGrid *) 0 ;
17739 wxGridCellCoordsArray result;
17740 void *argp1 = 0 ;
17741 int res1 = 0 ;
17742 PyObject *swig_obj[1] ;
17743
17744 if (!args) SWIG_fail;
17745 swig_obj[0] = args;
17746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17747 if (!SWIG_IsOK(res1)) {
17748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17749 }
17750 arg1 = reinterpret_cast< wxGrid * >(argp1);
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 resultobj = wxGridCellCoordsArray_helper(result);
17759 }
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17767 PyObject *resultobj = 0;
17768 wxGrid *arg1 = (wxGrid *) 0 ;
17769 wxGridCellCoordsArray result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 PyObject *swig_obj[1] ;
17773
17774 if (!args) SWIG_fail;
17775 swig_obj[0] = args;
17776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17777 if (!SWIG_IsOK(res1)) {
17778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17779 }
17780 arg1 = reinterpret_cast< wxGrid * >(argp1);
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 {
17788 resultobj = wxGridCellCoordsArray_helper(result);
17789 }
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17797 PyObject *resultobj = 0;
17798 wxGrid *arg1 = (wxGrid *) 0 ;
17799 wxArrayInt result;
17800 void *argp1 = 0 ;
17801 int res1 = 0 ;
17802 PyObject *swig_obj[1] ;
17803
17804 if (!args) SWIG_fail;
17805 swig_obj[0] = args;
17806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17807 if (!SWIG_IsOK(res1)) {
17808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17809 }
17810 arg1 = reinterpret_cast< wxGrid * >(argp1);
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = ((wxGrid const *)arg1)->GetSelectedRows();
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 resultobj = PyList_New(0);
17819 size_t idx;
17820 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17821 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17822 PyList_Append(resultobj, val);
17823 Py_DECREF(val);
17824 }
17825 }
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17833 PyObject *resultobj = 0;
17834 wxGrid *arg1 = (wxGrid *) 0 ;
17835 wxArrayInt result;
17836 void *argp1 = 0 ;
17837 int res1 = 0 ;
17838 PyObject *swig_obj[1] ;
17839
17840 if (!args) SWIG_fail;
17841 swig_obj[0] = args;
17842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17845 }
17846 arg1 = reinterpret_cast< wxGrid * >(argp1);
17847 {
17848 PyThreadState* __tstate = wxPyBeginAllowThreads();
17849 result = ((wxGrid const *)arg1)->GetSelectedCols();
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = PyList_New(0);
17855 size_t idx;
17856 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17857 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17858 PyList_Append(resultobj, val);
17859 Py_DECREF(val);
17860 }
17861 }
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17869 PyObject *resultobj = 0;
17870 wxGrid *arg1 = (wxGrid *) 0 ;
17871 int arg2 ;
17872 void *argp1 = 0 ;
17873 int res1 = 0 ;
17874 int val2 ;
17875 int ecode2 = 0 ;
17876 PyObject * obj0 = 0 ;
17877 PyObject * obj1 = 0 ;
17878 char * kwnames[] = {
17879 (char *) "self",(char *) "row", NULL
17880 };
17881
17882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17886 }
17887 arg1 = reinterpret_cast< wxGrid * >(argp1);
17888 ecode2 = SWIG_AsVal_int(obj1, &val2);
17889 if (!SWIG_IsOK(ecode2)) {
17890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17891 }
17892 arg2 = static_cast< int >(val2);
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 (arg1)->DeselectRow(arg2);
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 resultobj = SWIG_Py_Void();
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj = 0;
17908 wxGrid *arg1 = (wxGrid *) 0 ;
17909 int arg2 ;
17910 void *argp1 = 0 ;
17911 int res1 = 0 ;
17912 int val2 ;
17913 int ecode2 = 0 ;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 char * kwnames[] = {
17917 (char *) "self",(char *) "col", NULL
17918 };
17919
17920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17922 if (!SWIG_IsOK(res1)) {
17923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17924 }
17925 arg1 = reinterpret_cast< wxGrid * >(argp1);
17926 ecode2 = SWIG_AsVal_int(obj1, &val2);
17927 if (!SWIG_IsOK(ecode2)) {
17928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17929 }
17930 arg2 = static_cast< int >(val2);
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 (arg1)->DeselectCol(arg2);
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 resultobj = SWIG_Py_Void();
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj = 0;
17946 wxGrid *arg1 = (wxGrid *) 0 ;
17947 int arg2 ;
17948 int arg3 ;
17949 void *argp1 = 0 ;
17950 int res1 = 0 ;
17951 int val2 ;
17952 int ecode2 = 0 ;
17953 int val3 ;
17954 int ecode3 = 0 ;
17955 PyObject * obj0 = 0 ;
17956 PyObject * obj1 = 0 ;
17957 PyObject * obj2 = 0 ;
17958 char * kwnames[] = {
17959 (char *) "self",(char *) "row",(char *) "col", NULL
17960 };
17961
17962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17964 if (!SWIG_IsOK(res1)) {
17965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17966 }
17967 arg1 = reinterpret_cast< wxGrid * >(argp1);
17968 ecode2 = SWIG_AsVal_int(obj1, &val2);
17969 if (!SWIG_IsOK(ecode2)) {
17970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17971 }
17972 arg2 = static_cast< int >(val2);
17973 ecode3 = SWIG_AsVal_int(obj2, &val3);
17974 if (!SWIG_IsOK(ecode3)) {
17975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17976 }
17977 arg3 = static_cast< int >(val3);
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 (arg1)->DeselectCell(arg2,arg3);
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 resultobj = SWIG_Py_Void();
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj = 0;
17993 wxGrid *arg1 = (wxGrid *) 0 ;
17994 wxGridCellCoords *arg2 = 0 ;
17995 wxGridCellCoords *arg3 = 0 ;
17996 wxRect result;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 wxGridCellCoords temp2 ;
18000 wxGridCellCoords temp3 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 PyObject * obj2 = 0 ;
18004 char * kwnames[] = {
18005 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18006 };
18007
18008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18010 if (!SWIG_IsOK(res1)) {
18011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18012 }
18013 arg1 = reinterpret_cast< wxGrid * >(argp1);
18014 {
18015 arg2 = &temp2;
18016 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18017 }
18018 {
18019 arg3 = &temp3;
18020 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18021 }
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxGrid *arg1 = (wxGrid *) 0 ;
18038 wxColour result;
18039 void *argp1 = 0 ;
18040 int res1 = 0 ;
18041 PyObject *swig_obj[1] ;
18042
18043 if (!args) SWIG_fail;
18044 swig_obj[0] = args;
18045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18046 if (!SWIG_IsOK(res1)) {
18047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18048 }
18049 arg1 = reinterpret_cast< wxGrid * >(argp1);
18050 {
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *resultobj = 0;
18065 wxGrid *arg1 = (wxGrid *) 0 ;
18066 wxColour 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_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18076 }
18077 arg1 = reinterpret_cast< wxGrid * >(argp1);
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj = 0;
18093 wxGrid *arg1 = (wxGrid *) 0 ;
18094 wxColour *arg2 = 0 ;
18095 void *argp1 = 0 ;
18096 int res1 = 0 ;
18097 wxColour temp2 ;
18098 PyObject * obj0 = 0 ;
18099 PyObject * obj1 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "c", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18108 }
18109 arg1 = reinterpret_cast< wxGrid * >(argp1);
18110 {
18111 arg2 = &temp2;
18112 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_Py_Void();
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj = 0;
18129 wxGrid *arg1 = (wxGrid *) 0 ;
18130 wxColour *arg2 = 0 ;
18131 void *argp1 = 0 ;
18132 int res1 = 0 ;
18133 wxColour temp2 ;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 char * kwnames[] = {
18137 (char *) "self",(char *) "c", NULL
18138 };
18139
18140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18142 if (!SWIG_IsOK(res1)) {
18143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18144 }
18145 arg1 = reinterpret_cast< wxGrid * >(argp1);
18146 {
18147 arg2 = &temp2;
18148 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18149 }
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = SWIG_Py_Void();
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj = 0;
18165 wxGrid *arg1 = (wxGrid *) 0 ;
18166 wxString *arg2 = 0 ;
18167 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18168 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18169 void *argp1 = 0 ;
18170 int res1 = 0 ;
18171 bool temp2 = false ;
18172 void *argp3 = 0 ;
18173 int res3 = 0 ;
18174 void *argp4 = 0 ;
18175 int res4 = 0 ;
18176 PyObject * obj0 = 0 ;
18177 PyObject * obj1 = 0 ;
18178 PyObject * obj2 = 0 ;
18179 PyObject * obj3 = 0 ;
18180 char * kwnames[] = {
18181 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18182 };
18183
18184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18186 if (!SWIG_IsOK(res1)) {
18187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18188 }
18189 arg1 = reinterpret_cast< wxGrid * >(argp1);
18190 {
18191 arg2 = wxString_in_helper(obj1);
18192 if (arg2 == NULL) SWIG_fail;
18193 temp2 = true;
18194 }
18195 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18196 if (!SWIG_IsOK(res3)) {
18197 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18198 }
18199 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18200 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18201 if (!SWIG_IsOK(res4)) {
18202 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18203 }
18204 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = SWIG_Py_Void();
18212 {
18213 if (temp2)
18214 delete arg2;
18215 }
18216 return resultobj;
18217 fail:
18218 {
18219 if (temp2)
18220 delete arg2;
18221 }
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj = 0;
18228 wxGrid *arg1 = (wxGrid *) 0 ;
18229 int arg2 ;
18230 int arg3 ;
18231 wxGridCellEditor *result = 0 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 int val2 ;
18235 int ecode2 = 0 ;
18236 int val3 ;
18237 int ecode3 = 0 ;
18238 PyObject * obj0 = 0 ;
18239 PyObject * obj1 = 0 ;
18240 PyObject * obj2 = 0 ;
18241 char * kwnames[] = {
18242 (char *) "self",(char *) "row",(char *) "col", NULL
18243 };
18244
18245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18247 if (!SWIG_IsOK(res1)) {
18248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18249 }
18250 arg1 = reinterpret_cast< wxGrid * >(argp1);
18251 ecode2 = SWIG_AsVal_int(obj1, &val2);
18252 if (!SWIG_IsOK(ecode2)) {
18253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18254 }
18255 arg2 = static_cast< int >(val2);
18256 ecode3 = SWIG_AsVal_int(obj2, &val3);
18257 if (!SWIG_IsOK(ecode3)) {
18258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18259 }
18260 arg3 = static_cast< int >(val3);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 {
18268 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18269 }
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj = 0;
18278 wxGrid *arg1 = (wxGrid *) 0 ;
18279 int arg2 ;
18280 int arg3 ;
18281 wxGridCellRenderer *result = 0 ;
18282 void *argp1 = 0 ;
18283 int res1 = 0 ;
18284 int val2 ;
18285 int ecode2 = 0 ;
18286 int val3 ;
18287 int ecode3 = 0 ;
18288 PyObject * obj0 = 0 ;
18289 PyObject * obj1 = 0 ;
18290 PyObject * obj2 = 0 ;
18291 char * kwnames[] = {
18292 (char *) "self",(char *) "row",(char *) "col", NULL
18293 };
18294
18295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18297 if (!SWIG_IsOK(res1)) {
18298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18299 }
18300 arg1 = reinterpret_cast< wxGrid * >(argp1);
18301 ecode2 = SWIG_AsVal_int(obj1, &val2);
18302 if (!SWIG_IsOK(ecode2)) {
18303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18304 }
18305 arg2 = static_cast< int >(val2);
18306 ecode3 = SWIG_AsVal_int(obj2, &val3);
18307 if (!SWIG_IsOK(ecode3)) {
18308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18309 }
18310 arg3 = static_cast< int >(val3);
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18314 wxPyEndAllowThreads(__tstate);
18315 if (PyErr_Occurred()) SWIG_fail;
18316 }
18317 {
18318 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18319 }
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = 0;
18328 wxGrid *arg1 = (wxGrid *) 0 ;
18329 wxString *arg2 = 0 ;
18330 wxGridCellEditor *result = 0 ;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 bool temp2 = false ;
18334 PyObject * obj0 = 0 ;
18335 PyObject * obj1 = 0 ;
18336 char * kwnames[] = {
18337 (char *) "self",(char *) "typeName", NULL
18338 };
18339
18340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18344 }
18345 arg1 = reinterpret_cast< wxGrid * >(argp1);
18346 {
18347 arg2 = wxString_in_helper(obj1);
18348 if (arg2 == NULL) SWIG_fail;
18349 temp2 = true;
18350 }
18351 {
18352 PyThreadState* __tstate = wxPyBeginAllowThreads();
18353 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 {
18358 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18359 }
18360 {
18361 if (temp2)
18362 delete arg2;
18363 }
18364 return resultobj;
18365 fail:
18366 {
18367 if (temp2)
18368 delete arg2;
18369 }
18370 return NULL;
18371 }
18372
18373
18374 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18375 PyObject *resultobj = 0;
18376 wxGrid *arg1 = (wxGrid *) 0 ;
18377 wxString *arg2 = 0 ;
18378 wxGridCellRenderer *result = 0 ;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 bool temp2 = false ;
18382 PyObject * obj0 = 0 ;
18383 PyObject * obj1 = 0 ;
18384 char * kwnames[] = {
18385 (char *) "self",(char *) "typeName", NULL
18386 };
18387
18388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18390 if (!SWIG_IsOK(res1)) {
18391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18392 }
18393 arg1 = reinterpret_cast< wxGrid * >(argp1);
18394 {
18395 arg2 = wxString_in_helper(obj1);
18396 if (arg2 == NULL) SWIG_fail;
18397 temp2 = true;
18398 }
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 {
18406 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18407 }
18408 {
18409 if (temp2)
18410 delete arg2;
18411 }
18412 return resultobj;
18413 fail:
18414 {
18415 if (temp2)
18416 delete arg2;
18417 }
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj = 0;
18424 wxGrid *arg1 = (wxGrid *) 0 ;
18425 int arg2 ;
18426 int arg3 ;
18427 void *argp1 = 0 ;
18428 int res1 = 0 ;
18429 int val2 ;
18430 int ecode2 = 0 ;
18431 int val3 ;
18432 int ecode3 = 0 ;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 PyObject * obj2 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18444 }
18445 arg1 = reinterpret_cast< wxGrid * >(argp1);
18446 ecode2 = SWIG_AsVal_int(obj1, &val2);
18447 if (!SWIG_IsOK(ecode2)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18449 }
18450 arg2 = static_cast< int >(val2);
18451 ecode3 = SWIG_AsVal_int(obj2, &val3);
18452 if (!SWIG_IsOK(ecode3)) {
18453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18454 }
18455 arg3 = static_cast< int >(val3);
18456 {
18457 PyThreadState* __tstate = wxPyBeginAllowThreads();
18458 (arg1)->SetMargins(arg2,arg3);
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 resultobj = SWIG_Py_Void();
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18470 PyObject *resultobj = 0;
18471 wxGrid *arg1 = (wxGrid *) 0 ;
18472 wxWindow *result = 0 ;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 PyObject *swig_obj[1] ;
18476
18477 if (!args) SWIG_fail;
18478 swig_obj[0] = args;
18479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18482 }
18483 arg1 = reinterpret_cast< wxGrid * >(argp1);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (wxWindow *)(arg1)->GetGridWindow();
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 {
18491 resultobj = wxPyMake_wxObject(result, 0);
18492 }
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18500 PyObject *resultobj = 0;
18501 wxGrid *arg1 = (wxGrid *) 0 ;
18502 wxWindow *result = 0 ;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 PyObject *swig_obj[1] ;
18506
18507 if (!args) SWIG_fail;
18508 swig_obj[0] = args;
18509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18512 }
18513 arg1 = reinterpret_cast< wxGrid * >(argp1);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 {
18521 resultobj = wxPyMake_wxObject(result, 0);
18522 }
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *resultobj = 0;
18531 wxGrid *arg1 = (wxGrid *) 0 ;
18532 wxWindow *result = 0 ;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 PyObject *swig_obj[1] ;
18536
18537 if (!args) SWIG_fail;
18538 swig_obj[0] = args;
18539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18542 }
18543 arg1 = reinterpret_cast< wxGrid * >(argp1);
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 {
18551 resultobj = wxPyMake_wxObject(result, 0);
18552 }
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18560 PyObject *resultobj = 0;
18561 wxGrid *arg1 = (wxGrid *) 0 ;
18562 wxWindow *result = 0 ;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 PyObject *swig_obj[1] ;
18566
18567 if (!args) SWIG_fail;
18568 swig_obj[0] = args;
18569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18570 if (!SWIG_IsOK(res1)) {
18571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18572 }
18573 arg1 = reinterpret_cast< wxGrid * >(argp1);
18574 {
18575 PyThreadState* __tstate = wxPyBeginAllowThreads();
18576 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 {
18581 resultobj = wxPyMake_wxObject(result, 0);
18582 }
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj = 0;
18591 wxGrid *arg1 = (wxGrid *) 0 ;
18592 int arg2 ;
18593 void *argp1 = 0 ;
18594 int res1 = 0 ;
18595 int val2 ;
18596 int ecode2 = 0 ;
18597 PyObject * obj0 = 0 ;
18598 PyObject * obj1 = 0 ;
18599 char * kwnames[] = {
18600 (char *) "self",(char *) "x", NULL
18601 };
18602
18603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18607 }
18608 arg1 = reinterpret_cast< wxGrid * >(argp1);
18609 ecode2 = SWIG_AsVal_int(obj1, &val2);
18610 if (!SWIG_IsOK(ecode2)) {
18611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18612 }
18613 arg2 = static_cast< int >(val2);
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 (arg1)->SetScrollLineX(arg2);
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 resultobj = SWIG_Py_Void();
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18628 PyObject *resultobj = 0;
18629 wxGrid *arg1 = (wxGrid *) 0 ;
18630 int arg2 ;
18631 void *argp1 = 0 ;
18632 int res1 = 0 ;
18633 int val2 ;
18634 int ecode2 = 0 ;
18635 PyObject * obj0 = 0 ;
18636 PyObject * obj1 = 0 ;
18637 char * kwnames[] = {
18638 (char *) "self",(char *) "y", NULL
18639 };
18640
18641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18643 if (!SWIG_IsOK(res1)) {
18644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18645 }
18646 arg1 = reinterpret_cast< wxGrid * >(argp1);
18647 ecode2 = SWIG_AsVal_int(obj1, &val2);
18648 if (!SWIG_IsOK(ecode2)) {
18649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18650 }
18651 arg2 = static_cast< int >(val2);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 (arg1)->SetScrollLineY(arg2);
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 resultobj = SWIG_Py_Void();
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18666 PyObject *resultobj = 0;
18667 wxGrid *arg1 = (wxGrid *) 0 ;
18668 int result;
18669 void *argp1 = 0 ;
18670 int res1 = 0 ;
18671 PyObject *swig_obj[1] ;
18672
18673 if (!args) SWIG_fail;
18674 swig_obj[0] = args;
18675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18676 if (!SWIG_IsOK(res1)) {
18677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18678 }
18679 arg1 = reinterpret_cast< wxGrid * >(argp1);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_From_int(static_cast< int >(result));
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxGrid *arg1 = (wxGrid *) 0 ;
18696 int result;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18706 }
18707 arg1 = reinterpret_cast< wxGrid * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_From_int(static_cast< int >(result));
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18722 PyObject *resultobj = 0;
18723 wxGrid *arg1 = (wxGrid *) 0 ;
18724 int arg2 ;
18725 int result;
18726 void *argp1 = 0 ;
18727 int res1 = 0 ;
18728 int val2 ;
18729 int ecode2 = 0 ;
18730 PyObject * obj0 = 0 ;
18731 PyObject * obj1 = 0 ;
18732 char * kwnames[] = {
18733 (char *) "self",(char *) "x", NULL
18734 };
18735
18736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18740 }
18741 arg1 = reinterpret_cast< wxGrid * >(argp1);
18742 ecode2 = SWIG_AsVal_int(obj1, &val2);
18743 if (!SWIG_IsOK(ecode2)) {
18744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18745 }
18746 arg2 = static_cast< int >(val2);
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_From_int(static_cast< int >(result));
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = 0;
18762 wxGrid *arg1 = (wxGrid *) 0 ;
18763 int arg2 ;
18764 int result;
18765 void *argp1 = 0 ;
18766 int res1 = 0 ;
18767 int val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "y", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18779 }
18780 arg1 = reinterpret_cast< wxGrid * >(argp1);
18781 ecode2 = SWIG_AsVal_int(obj1, &val2);
18782 if (!SWIG_IsOK(ecode2)) {
18783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18784 }
18785 arg2 = static_cast< int >(val2);
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 resultobj = SWIG_From_int(static_cast< int >(result));
18793 return resultobj;
18794 fail:
18795 return NULL;
18796 }
18797
18798
18799 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18800 PyObject *resultobj = 0;
18801 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18802 SwigValueWrapper<wxVisualAttributes > result;
18803 int val1 ;
18804 int ecode1 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 char * kwnames[] = {
18807 (char *) "variant", NULL
18808 };
18809
18810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18811 if (obj0) {
18812 ecode1 = SWIG_AsVal_int(obj0, &val1);
18813 if (!SWIG_IsOK(ecode1)) {
18814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18815 }
18816 arg1 = static_cast< wxWindowVariant >(val1);
18817 }
18818 {
18819 if (!wxPyCheckForApp()) SWIG_fail;
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = wxGrid::GetClassDefaultAttributes(arg1);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *obj;
18834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18835 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18836 return SWIG_Py_Void();
18837 }
18838
18839 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 return SWIG_Python_InitShadowInstance(args);
18841 }
18842
18843 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 int arg1 ;
18846 wxEventType arg2 ;
18847 wxGrid *arg3 = (wxGrid *) 0 ;
18848 int arg4 = (int) -1 ;
18849 int arg5 = (int) -1 ;
18850 int arg6 = (int) -1 ;
18851 int arg7 = (int) -1 ;
18852 bool arg8 = (bool) true ;
18853 bool arg9 = (bool) false ;
18854 bool arg10 = (bool) false ;
18855 bool arg11 = (bool) false ;
18856 bool arg12 = (bool) false ;
18857 wxGridEvent *result = 0 ;
18858 int val1 ;
18859 int ecode1 = 0 ;
18860 int val2 ;
18861 int ecode2 = 0 ;
18862 void *argp3 = 0 ;
18863 int res3 = 0 ;
18864 int val4 ;
18865 int ecode4 = 0 ;
18866 int val5 ;
18867 int ecode5 = 0 ;
18868 int val6 ;
18869 int ecode6 = 0 ;
18870 int val7 ;
18871 int ecode7 = 0 ;
18872 bool val8 ;
18873 int ecode8 = 0 ;
18874 bool val9 ;
18875 int ecode9 = 0 ;
18876 bool val10 ;
18877 int ecode10 = 0 ;
18878 bool val11 ;
18879 int ecode11 = 0 ;
18880 bool val12 ;
18881 int ecode12 = 0 ;
18882 PyObject * obj0 = 0 ;
18883 PyObject * obj1 = 0 ;
18884 PyObject * obj2 = 0 ;
18885 PyObject * obj3 = 0 ;
18886 PyObject * obj4 = 0 ;
18887 PyObject * obj5 = 0 ;
18888 PyObject * obj6 = 0 ;
18889 PyObject * obj7 = 0 ;
18890 PyObject * obj8 = 0 ;
18891 PyObject * obj9 = 0 ;
18892 PyObject * obj10 = 0 ;
18893 PyObject * obj11 = 0 ;
18894 char * kwnames[] = {
18895 (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
18896 };
18897
18898 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;
18899 ecode1 = SWIG_AsVal_int(obj0, &val1);
18900 if (!SWIG_IsOK(ecode1)) {
18901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18902 }
18903 arg1 = static_cast< int >(val1);
18904 ecode2 = SWIG_AsVal_int(obj1, &val2);
18905 if (!SWIG_IsOK(ecode2)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18907 }
18908 arg2 = static_cast< wxEventType >(val2);
18909 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18910 if (!SWIG_IsOK(res3)) {
18911 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18912 }
18913 arg3 = reinterpret_cast< wxGrid * >(argp3);
18914 if (obj3) {
18915 ecode4 = SWIG_AsVal_int(obj3, &val4);
18916 if (!SWIG_IsOK(ecode4)) {
18917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18918 }
18919 arg4 = static_cast< int >(val4);
18920 }
18921 if (obj4) {
18922 ecode5 = SWIG_AsVal_int(obj4, &val5);
18923 if (!SWIG_IsOK(ecode5)) {
18924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18925 }
18926 arg5 = static_cast< int >(val5);
18927 }
18928 if (obj5) {
18929 ecode6 = SWIG_AsVal_int(obj5, &val6);
18930 if (!SWIG_IsOK(ecode6)) {
18931 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18932 }
18933 arg6 = static_cast< int >(val6);
18934 }
18935 if (obj6) {
18936 ecode7 = SWIG_AsVal_int(obj6, &val7);
18937 if (!SWIG_IsOK(ecode7)) {
18938 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18939 }
18940 arg7 = static_cast< int >(val7);
18941 }
18942 if (obj7) {
18943 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18944 if (!SWIG_IsOK(ecode8)) {
18945 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18946 }
18947 arg8 = static_cast< bool >(val8);
18948 }
18949 if (obj8) {
18950 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18951 if (!SWIG_IsOK(ecode9)) {
18952 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18953 }
18954 arg9 = static_cast< bool >(val9);
18955 }
18956 if (obj9) {
18957 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18958 if (!SWIG_IsOK(ecode10)) {
18959 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18960 }
18961 arg10 = static_cast< bool >(val10);
18962 }
18963 if (obj10) {
18964 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18965 if (!SWIG_IsOK(ecode11)) {
18966 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18967 }
18968 arg11 = static_cast< bool >(val11);
18969 }
18970 if (obj11) {
18971 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18972 if (!SWIG_IsOK(ecode12)) {
18973 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18974 }
18975 arg12 = static_cast< bool >(val12);
18976 }
18977 {
18978 PyThreadState* __tstate = wxPyBeginAllowThreads();
18979 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18984 return resultobj;
18985 fail:
18986 return NULL;
18987 }
18988
18989
18990 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18991 PyObject *resultobj = 0;
18992 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18993 int result;
18994 void *argp1 = 0 ;
18995 int res1 = 0 ;
18996 PyObject *swig_obj[1] ;
18997
18998 if (!args) SWIG_fail;
18999 swig_obj[0] = args;
19000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19001 if (!SWIG_IsOK(res1)) {
19002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19003 }
19004 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19005 {
19006 PyThreadState* __tstate = wxPyBeginAllowThreads();
19007 result = (int)(arg1)->GetRow();
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 resultobj = SWIG_From_int(static_cast< int >(result));
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19019 PyObject *resultobj = 0;
19020 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19021 int result;
19022 void *argp1 = 0 ;
19023 int res1 = 0 ;
19024 PyObject *swig_obj[1] ;
19025
19026 if (!args) SWIG_fail;
19027 swig_obj[0] = args;
19028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19029 if (!SWIG_IsOK(res1)) {
19030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19031 }
19032 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = (int)(arg1)->GetCol();
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_From_int(static_cast< int >(result));
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19047 PyObject *resultobj = 0;
19048 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19049 wxPoint result;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 PyObject *swig_obj[1] ;
19053
19054 if (!args) SWIG_fail;
19055 swig_obj[0] = args;
19056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19057 if (!SWIG_IsOK(res1)) {
19058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19059 }
19060 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 result = (arg1)->GetPosition();
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19075 PyObject *resultobj = 0;
19076 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19077 bool result;
19078 void *argp1 = 0 ;
19079 int res1 = 0 ;
19080 PyObject *swig_obj[1] ;
19081
19082 if (!args) SWIG_fail;
19083 swig_obj[0] = args;
19084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19085 if (!SWIG_IsOK(res1)) {
19086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19087 }
19088 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19089 {
19090 PyThreadState* __tstate = wxPyBeginAllowThreads();
19091 result = (bool)(arg1)->Selecting();
19092 wxPyEndAllowThreads(__tstate);
19093 if (PyErr_Occurred()) SWIG_fail;
19094 }
19095 {
19096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19097 }
19098 return resultobj;
19099 fail:
19100 return NULL;
19101 }
19102
19103
19104 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19105 PyObject *resultobj = 0;
19106 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19107 bool result;
19108 void *argp1 = 0 ;
19109 int res1 = 0 ;
19110 PyObject *swig_obj[1] ;
19111
19112 if (!args) SWIG_fail;
19113 swig_obj[0] = args;
19114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19115 if (!SWIG_IsOK(res1)) {
19116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19117 }
19118 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19119 {
19120 PyThreadState* __tstate = wxPyBeginAllowThreads();
19121 result = (bool)(arg1)->ControlDown();
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 {
19126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19127 }
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19137 bool result;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19147 }
19148 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (bool)(arg1)->MetaDown();
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 {
19156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19157 }
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165 PyObject *resultobj = 0;
19166 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19167 bool result;
19168 void *argp1 = 0 ;
19169 int res1 = 0 ;
19170 PyObject *swig_obj[1] ;
19171
19172 if (!args) SWIG_fail;
19173 swig_obj[0] = args;
19174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19175 if (!SWIG_IsOK(res1)) {
19176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19177 }
19178 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 result = (bool)(arg1)->ShiftDown();
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 {
19186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19187 }
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19195 PyObject *resultobj = 0;
19196 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19197 bool result;
19198 void *argp1 = 0 ;
19199 int res1 = 0 ;
19200 PyObject *swig_obj[1] ;
19201
19202 if (!args) SWIG_fail;
19203 swig_obj[0] = args;
19204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19205 if (!SWIG_IsOK(res1)) {
19206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19207 }
19208 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 result = (bool)(arg1)->AltDown();
19212 wxPyEndAllowThreads(__tstate);
19213 if (PyErr_Occurred()) SWIG_fail;
19214 }
19215 {
19216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19217 }
19218 return resultobj;
19219 fail:
19220 return NULL;
19221 }
19222
19223
19224 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19225 PyObject *resultobj = 0;
19226 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19227 bool result;
19228 void *argp1 = 0 ;
19229 int res1 = 0 ;
19230 PyObject *swig_obj[1] ;
19231
19232 if (!args) SWIG_fail;
19233 swig_obj[0] = args;
19234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19235 if (!SWIG_IsOK(res1)) {
19236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19237 }
19238 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (bool)(arg1)->CmdDown();
19242 wxPyEndAllowThreads(__tstate);
19243 if (PyErr_Occurred()) SWIG_fail;
19244 }
19245 {
19246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19247 }
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19255 PyObject *obj;
19256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19257 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19258 return SWIG_Py_Void();
19259 }
19260
19261 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19262 return SWIG_Python_InitShadowInstance(args);
19263 }
19264
19265 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19266 PyObject *resultobj = 0;
19267 int arg1 ;
19268 wxEventType arg2 ;
19269 wxGrid *arg3 = (wxGrid *) 0 ;
19270 int arg4 = (int) -1 ;
19271 int arg5 = (int) -1 ;
19272 int arg6 = (int) -1 ;
19273 bool arg7 = (bool) false ;
19274 bool arg8 = (bool) false ;
19275 bool arg9 = (bool) false ;
19276 bool arg10 = (bool) false ;
19277 wxGridSizeEvent *result = 0 ;
19278 int val1 ;
19279 int ecode1 = 0 ;
19280 int val2 ;
19281 int ecode2 = 0 ;
19282 void *argp3 = 0 ;
19283 int res3 = 0 ;
19284 int val4 ;
19285 int ecode4 = 0 ;
19286 int val5 ;
19287 int ecode5 = 0 ;
19288 int val6 ;
19289 int ecode6 = 0 ;
19290 bool val7 ;
19291 int ecode7 = 0 ;
19292 bool val8 ;
19293 int ecode8 = 0 ;
19294 bool val9 ;
19295 int ecode9 = 0 ;
19296 bool val10 ;
19297 int ecode10 = 0 ;
19298 PyObject * obj0 = 0 ;
19299 PyObject * obj1 = 0 ;
19300 PyObject * obj2 = 0 ;
19301 PyObject * obj3 = 0 ;
19302 PyObject * obj4 = 0 ;
19303 PyObject * obj5 = 0 ;
19304 PyObject * obj6 = 0 ;
19305 PyObject * obj7 = 0 ;
19306 PyObject * obj8 = 0 ;
19307 PyObject * obj9 = 0 ;
19308 char * kwnames[] = {
19309 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19310 };
19311
19312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19313 ecode1 = SWIG_AsVal_int(obj0, &val1);
19314 if (!SWIG_IsOK(ecode1)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19316 }
19317 arg1 = static_cast< int >(val1);
19318 ecode2 = SWIG_AsVal_int(obj1, &val2);
19319 if (!SWIG_IsOK(ecode2)) {
19320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19321 }
19322 arg2 = static_cast< wxEventType >(val2);
19323 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19324 if (!SWIG_IsOK(res3)) {
19325 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19326 }
19327 arg3 = reinterpret_cast< wxGrid * >(argp3);
19328 if (obj3) {
19329 ecode4 = SWIG_AsVal_int(obj3, &val4);
19330 if (!SWIG_IsOK(ecode4)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19332 }
19333 arg4 = static_cast< int >(val4);
19334 }
19335 if (obj4) {
19336 ecode5 = SWIG_AsVal_int(obj4, &val5);
19337 if (!SWIG_IsOK(ecode5)) {
19338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19339 }
19340 arg5 = static_cast< int >(val5);
19341 }
19342 if (obj5) {
19343 ecode6 = SWIG_AsVal_int(obj5, &val6);
19344 if (!SWIG_IsOK(ecode6)) {
19345 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19346 }
19347 arg6 = static_cast< int >(val6);
19348 }
19349 if (obj6) {
19350 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19351 if (!SWIG_IsOK(ecode7)) {
19352 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19353 }
19354 arg7 = static_cast< bool >(val7);
19355 }
19356 if (obj7) {
19357 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19358 if (!SWIG_IsOK(ecode8)) {
19359 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19360 }
19361 arg8 = static_cast< bool >(val8);
19362 }
19363 if (obj8) {
19364 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19365 if (!SWIG_IsOK(ecode9)) {
19366 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19367 }
19368 arg9 = static_cast< bool >(val9);
19369 }
19370 if (obj9) {
19371 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19372 if (!SWIG_IsOK(ecode10)) {
19373 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19374 }
19375 arg10 = static_cast< bool >(val10);
19376 }
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19391 PyObject *resultobj = 0;
19392 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19393 int result;
19394 void *argp1 = 0 ;
19395 int res1 = 0 ;
19396 PyObject *swig_obj[1] ;
19397
19398 if (!args) SWIG_fail;
19399 swig_obj[0] = args;
19400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19401 if (!SWIG_IsOK(res1)) {
19402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19403 }
19404 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (int)(arg1)->GetRowOrCol();
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_From_int(static_cast< int >(result));
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19419 PyObject *resultobj = 0;
19420 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19421 wxPoint result;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject *swig_obj[1] ;
19425
19426 if (!args) SWIG_fail;
19427 swig_obj[0] = args;
19428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19429 if (!SWIG_IsOK(res1)) {
19430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19431 }
19432 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = (arg1)->GetPosition();
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 PyObject *resultobj = 0;
19448 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19449 bool result;
19450 void *argp1 = 0 ;
19451 int res1 = 0 ;
19452 PyObject *swig_obj[1] ;
19453
19454 if (!args) SWIG_fail;
19455 swig_obj[0] = args;
19456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19459 }
19460 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (bool)(arg1)->ControlDown();
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 {
19468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19469 }
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19479 bool result;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 PyObject *swig_obj[1] ;
19483
19484 if (!args) SWIG_fail;
19485 swig_obj[0] = args;
19486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19489 }
19490 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (bool)(arg1)->MetaDown();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19499 }
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 PyObject *resultobj = 0;
19508 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19509 bool result;
19510 void *argp1 = 0 ;
19511 int res1 = 0 ;
19512 PyObject *swig_obj[1] ;
19513
19514 if (!args) SWIG_fail;
19515 swig_obj[0] = args;
19516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19517 if (!SWIG_IsOK(res1)) {
19518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19519 }
19520 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 result = (bool)(arg1)->ShiftDown();
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 {
19528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19529 }
19530 return resultobj;
19531 fail:
19532 return NULL;
19533 }
19534
19535
19536 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19537 PyObject *resultobj = 0;
19538 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19539 bool result;
19540 void *argp1 = 0 ;
19541 int res1 = 0 ;
19542 PyObject *swig_obj[1] ;
19543
19544 if (!args) SWIG_fail;
19545 swig_obj[0] = args;
19546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19547 if (!SWIG_IsOK(res1)) {
19548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19549 }
19550 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 result = (bool)(arg1)->AltDown();
19554 wxPyEndAllowThreads(__tstate);
19555 if (PyErr_Occurred()) SWIG_fail;
19556 }
19557 {
19558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19559 }
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19567 PyObject *resultobj = 0;
19568 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19569 bool result;
19570 void *argp1 = 0 ;
19571 int res1 = 0 ;
19572 PyObject *swig_obj[1] ;
19573
19574 if (!args) SWIG_fail;
19575 swig_obj[0] = args;
19576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19577 if (!SWIG_IsOK(res1)) {
19578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19579 }
19580 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = (bool)(arg1)->CmdDown();
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 {
19588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19589 }
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19597 PyObject *obj;
19598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19599 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19600 return SWIG_Py_Void();
19601 }
19602
19603 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19604 return SWIG_Python_InitShadowInstance(args);
19605 }
19606
19607 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj = 0;
19609 int arg1 ;
19610 wxEventType arg2 ;
19611 wxGrid *arg3 = (wxGrid *) 0 ;
19612 wxGridCellCoords *arg4 = 0 ;
19613 wxGridCellCoords *arg5 = 0 ;
19614 bool arg6 = (bool) true ;
19615 bool arg7 = (bool) false ;
19616 bool arg8 = (bool) false ;
19617 bool arg9 = (bool) false ;
19618 bool arg10 = (bool) false ;
19619 wxGridRangeSelectEvent *result = 0 ;
19620 int val1 ;
19621 int ecode1 = 0 ;
19622 int val2 ;
19623 int ecode2 = 0 ;
19624 void *argp3 = 0 ;
19625 int res3 = 0 ;
19626 wxGridCellCoords temp4 ;
19627 wxGridCellCoords temp5 ;
19628 bool val6 ;
19629 int ecode6 = 0 ;
19630 bool val7 ;
19631 int ecode7 = 0 ;
19632 bool val8 ;
19633 int ecode8 = 0 ;
19634 bool val9 ;
19635 int ecode9 = 0 ;
19636 bool val10 ;
19637 int ecode10 = 0 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 PyObject * obj2 = 0 ;
19641 PyObject * obj3 = 0 ;
19642 PyObject * obj4 = 0 ;
19643 PyObject * obj5 = 0 ;
19644 PyObject * obj6 = 0 ;
19645 PyObject * obj7 = 0 ;
19646 PyObject * obj8 = 0 ;
19647 PyObject * obj9 = 0 ;
19648 char * kwnames[] = {
19649 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19650 };
19651
19652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19653 ecode1 = SWIG_AsVal_int(obj0, &val1);
19654 if (!SWIG_IsOK(ecode1)) {
19655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19656 }
19657 arg1 = static_cast< int >(val1);
19658 ecode2 = SWIG_AsVal_int(obj1, &val2);
19659 if (!SWIG_IsOK(ecode2)) {
19660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19661 }
19662 arg2 = static_cast< wxEventType >(val2);
19663 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19664 if (!SWIG_IsOK(res3)) {
19665 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19666 }
19667 arg3 = reinterpret_cast< wxGrid * >(argp3);
19668 {
19669 arg4 = &temp4;
19670 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19671 }
19672 {
19673 arg5 = &temp5;
19674 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19675 }
19676 if (obj5) {
19677 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19678 if (!SWIG_IsOK(ecode6)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19680 }
19681 arg6 = static_cast< bool >(val6);
19682 }
19683 if (obj6) {
19684 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19685 if (!SWIG_IsOK(ecode7)) {
19686 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19687 }
19688 arg7 = static_cast< bool >(val7);
19689 }
19690 if (obj7) {
19691 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19692 if (!SWIG_IsOK(ecode8)) {
19693 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19694 }
19695 arg8 = static_cast< bool >(val8);
19696 }
19697 if (obj8) {
19698 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19699 if (!SWIG_IsOK(ecode9)) {
19700 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19701 }
19702 arg9 = static_cast< bool >(val9);
19703 }
19704 if (obj9) {
19705 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19706 if (!SWIG_IsOK(ecode10)) {
19707 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19708 }
19709 arg10 = static_cast< bool >(val10);
19710 }
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19725 PyObject *resultobj = 0;
19726 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19727 wxGridCellCoords result;
19728 void *argp1 = 0 ;
19729 int res1 = 0 ;
19730 PyObject *swig_obj[1] ;
19731
19732 if (!args) SWIG_fail;
19733 swig_obj[0] = args;
19734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19735 if (!SWIG_IsOK(res1)) {
19736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19737 }
19738 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (arg1)->GetTopLeftCoords();
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19746 return resultobj;
19747 fail:
19748 return NULL;
19749 }
19750
19751
19752 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19753 PyObject *resultobj = 0;
19754 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19755 wxGridCellCoords result;
19756 void *argp1 = 0 ;
19757 int res1 = 0 ;
19758 PyObject *swig_obj[1] ;
19759
19760 if (!args) SWIG_fail;
19761 swig_obj[0] = args;
19762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19763 if (!SWIG_IsOK(res1)) {
19764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19765 }
19766 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19767 {
19768 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 result = (arg1)->GetBottomRightCoords();
19770 wxPyEndAllowThreads(__tstate);
19771 if (PyErr_Occurred()) SWIG_fail;
19772 }
19773 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19774 return resultobj;
19775 fail:
19776 return NULL;
19777 }
19778
19779
19780 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19781 PyObject *resultobj = 0;
19782 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19783 int result;
19784 void *argp1 = 0 ;
19785 int res1 = 0 ;
19786 PyObject *swig_obj[1] ;
19787
19788 if (!args) SWIG_fail;
19789 swig_obj[0] = args;
19790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19791 if (!SWIG_IsOK(res1)) {
19792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19793 }
19794 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19795 {
19796 PyThreadState* __tstate = wxPyBeginAllowThreads();
19797 result = (int)(arg1)->GetTopRow();
19798 wxPyEndAllowThreads(__tstate);
19799 if (PyErr_Occurred()) SWIG_fail;
19800 }
19801 resultobj = SWIG_From_int(static_cast< int >(result));
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19809 PyObject *resultobj = 0;
19810 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19811 int result;
19812 void *argp1 = 0 ;
19813 int res1 = 0 ;
19814 PyObject *swig_obj[1] ;
19815
19816 if (!args) SWIG_fail;
19817 swig_obj[0] = args;
19818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19819 if (!SWIG_IsOK(res1)) {
19820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19821 }
19822 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19823 {
19824 PyThreadState* __tstate = wxPyBeginAllowThreads();
19825 result = (int)(arg1)->GetBottomRow();
19826 wxPyEndAllowThreads(__tstate);
19827 if (PyErr_Occurred()) SWIG_fail;
19828 }
19829 resultobj = SWIG_From_int(static_cast< int >(result));
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19837 PyObject *resultobj = 0;
19838 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19839 int result;
19840 void *argp1 = 0 ;
19841 int res1 = 0 ;
19842 PyObject *swig_obj[1] ;
19843
19844 if (!args) SWIG_fail;
19845 swig_obj[0] = args;
19846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19847 if (!SWIG_IsOK(res1)) {
19848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19849 }
19850 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19851 {
19852 PyThreadState* __tstate = wxPyBeginAllowThreads();
19853 result = (int)(arg1)->GetLeftCol();
19854 wxPyEndAllowThreads(__tstate);
19855 if (PyErr_Occurred()) SWIG_fail;
19856 }
19857 resultobj = SWIG_From_int(static_cast< int >(result));
19858 return resultobj;
19859 fail:
19860 return NULL;
19861 }
19862
19863
19864 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19865 PyObject *resultobj = 0;
19866 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19867 int result;
19868 void *argp1 = 0 ;
19869 int res1 = 0 ;
19870 PyObject *swig_obj[1] ;
19871
19872 if (!args) SWIG_fail;
19873 swig_obj[0] = args;
19874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19875 if (!SWIG_IsOK(res1)) {
19876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19877 }
19878 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19879 {
19880 PyThreadState* __tstate = wxPyBeginAllowThreads();
19881 result = (int)(arg1)->GetRightCol();
19882 wxPyEndAllowThreads(__tstate);
19883 if (PyErr_Occurred()) SWIG_fail;
19884 }
19885 resultobj = SWIG_From_int(static_cast< int >(result));
19886 return resultobj;
19887 fail:
19888 return NULL;
19889 }
19890
19891
19892 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19893 PyObject *resultobj = 0;
19894 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19895 bool result;
19896 void *argp1 = 0 ;
19897 int res1 = 0 ;
19898 PyObject *swig_obj[1] ;
19899
19900 if (!args) SWIG_fail;
19901 swig_obj[0] = args;
19902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19903 if (!SWIG_IsOK(res1)) {
19904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19905 }
19906 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19907 {
19908 PyThreadState* __tstate = wxPyBeginAllowThreads();
19909 result = (bool)(arg1)->Selecting();
19910 wxPyEndAllowThreads(__tstate);
19911 if (PyErr_Occurred()) SWIG_fail;
19912 }
19913 {
19914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19915 }
19916 return resultobj;
19917 fail:
19918 return NULL;
19919 }
19920
19921
19922 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19923 PyObject *resultobj = 0;
19924 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19925 bool result;
19926 void *argp1 = 0 ;
19927 int res1 = 0 ;
19928 PyObject *swig_obj[1] ;
19929
19930 if (!args) SWIG_fail;
19931 swig_obj[0] = args;
19932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19933 if (!SWIG_IsOK(res1)) {
19934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19935 }
19936 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 result = (bool)(arg1)->ControlDown();
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 {
19944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19945 }
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19953 PyObject *resultobj = 0;
19954 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 PyObject *swig_obj[1] ;
19959
19960 if (!args) SWIG_fail;
19961 swig_obj[0] = args;
19962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19965 }
19966 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)(arg1)->MetaDown();
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 {
19974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19975 }
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19983 PyObject *resultobj = 0;
19984 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19985 bool result;
19986 void *argp1 = 0 ;
19987 int res1 = 0 ;
19988 PyObject *swig_obj[1] ;
19989
19990 if (!args) SWIG_fail;
19991 swig_obj[0] = args;
19992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19993 if (!SWIG_IsOK(res1)) {
19994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19995 }
19996 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (bool)(arg1)->ShiftDown();
20000 wxPyEndAllowThreads(__tstate);
20001 if (PyErr_Occurred()) SWIG_fail;
20002 }
20003 {
20004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20005 }
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20013 PyObject *resultobj = 0;
20014 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20015 bool result;
20016 void *argp1 = 0 ;
20017 int res1 = 0 ;
20018 PyObject *swig_obj[1] ;
20019
20020 if (!args) SWIG_fail;
20021 swig_obj[0] = args;
20022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20025 }
20026 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (bool)(arg1)->AltDown();
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 {
20034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20043 PyObject *resultobj = 0;
20044 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20045 bool result;
20046 void *argp1 = 0 ;
20047 int res1 = 0 ;
20048 PyObject *swig_obj[1] ;
20049
20050 if (!args) SWIG_fail;
20051 swig_obj[0] = args;
20052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20053 if (!SWIG_IsOK(res1)) {
20054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20055 }
20056 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 result = (bool)(arg1)->CmdDown();
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 {
20064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20065 }
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20073 PyObject *obj;
20074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20075 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20076 return SWIG_Py_Void();
20077 }
20078
20079 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20080 return SWIG_Python_InitShadowInstance(args);
20081 }
20082
20083 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20084 PyObject *resultobj = 0;
20085 int arg1 ;
20086 wxEventType arg2 ;
20087 wxObject *arg3 = (wxObject *) 0 ;
20088 int arg4 ;
20089 int arg5 ;
20090 wxControl *arg6 = (wxControl *) 0 ;
20091 wxGridEditorCreatedEvent *result = 0 ;
20092 int val1 ;
20093 int ecode1 = 0 ;
20094 int val2 ;
20095 int ecode2 = 0 ;
20096 void *argp3 = 0 ;
20097 int res3 = 0 ;
20098 int val4 ;
20099 int ecode4 = 0 ;
20100 int val5 ;
20101 int ecode5 = 0 ;
20102 void *argp6 = 0 ;
20103 int res6 = 0 ;
20104 PyObject * obj0 = 0 ;
20105 PyObject * obj1 = 0 ;
20106 PyObject * obj2 = 0 ;
20107 PyObject * obj3 = 0 ;
20108 PyObject * obj4 = 0 ;
20109 PyObject * obj5 = 0 ;
20110 char * kwnames[] = {
20111 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20112 };
20113
20114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20115 ecode1 = SWIG_AsVal_int(obj0, &val1);
20116 if (!SWIG_IsOK(ecode1)) {
20117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20118 }
20119 arg1 = static_cast< int >(val1);
20120 ecode2 = SWIG_AsVal_int(obj1, &val2);
20121 if (!SWIG_IsOK(ecode2)) {
20122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20123 }
20124 arg2 = static_cast< wxEventType >(val2);
20125 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20126 if (!SWIG_IsOK(res3)) {
20127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20128 }
20129 arg3 = reinterpret_cast< wxObject * >(argp3);
20130 ecode4 = SWIG_AsVal_int(obj3, &val4);
20131 if (!SWIG_IsOK(ecode4)) {
20132 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20133 }
20134 arg4 = static_cast< int >(val4);
20135 ecode5 = SWIG_AsVal_int(obj4, &val5);
20136 if (!SWIG_IsOK(ecode5)) {
20137 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20138 }
20139 arg5 = static_cast< int >(val5);
20140 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20141 if (!SWIG_IsOK(res6)) {
20142 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20143 }
20144 arg6 = reinterpret_cast< wxControl * >(argp6);
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20161 int result;
20162 void *argp1 = 0 ;
20163 int res1 = 0 ;
20164 PyObject *swig_obj[1] ;
20165
20166 if (!args) SWIG_fail;
20167 swig_obj[0] = args;
20168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20169 if (!SWIG_IsOK(res1)) {
20170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20171 }
20172 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (int)(arg1)->GetRow();
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 resultobj = SWIG_From_int(static_cast< int >(result));
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20189 int result;
20190 void *argp1 = 0 ;
20191 int res1 = 0 ;
20192 PyObject *swig_obj[1] ;
20193
20194 if (!args) SWIG_fail;
20195 swig_obj[0] = args;
20196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20197 if (!SWIG_IsOK(res1)) {
20198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20199 }
20200 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 result = (int)(arg1)->GetCol();
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 resultobj = SWIG_From_int(static_cast< int >(result));
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20215 PyObject *resultobj = 0;
20216 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20217 wxControl *result = 0 ;
20218 void *argp1 = 0 ;
20219 int res1 = 0 ;
20220 PyObject *swig_obj[1] ;
20221
20222 if (!args) SWIG_fail;
20223 swig_obj[0] = args;
20224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20225 if (!SWIG_IsOK(res1)) {
20226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20227 }
20228 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 result = (wxControl *)(arg1)->GetControl();
20232 wxPyEndAllowThreads(__tstate);
20233 if (PyErr_Occurred()) SWIG_fail;
20234 }
20235 {
20236 resultobj = wxPyMake_wxObject(result, 0);
20237 }
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj = 0;
20246 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20247 int arg2 ;
20248 void *argp1 = 0 ;
20249 int res1 = 0 ;
20250 int val2 ;
20251 int ecode2 = 0 ;
20252 PyObject * obj0 = 0 ;
20253 PyObject * obj1 = 0 ;
20254 char * kwnames[] = {
20255 (char *) "self",(char *) "row", NULL
20256 };
20257
20258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20260 if (!SWIG_IsOK(res1)) {
20261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20262 }
20263 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20264 ecode2 = SWIG_AsVal_int(obj1, &val2);
20265 if (!SWIG_IsOK(ecode2)) {
20266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20267 }
20268 arg2 = static_cast< int >(val2);
20269 {
20270 PyThreadState* __tstate = wxPyBeginAllowThreads();
20271 (arg1)->SetRow(arg2);
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 resultobj = SWIG_Py_Void();
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj = 0;
20284 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20285 int arg2 ;
20286 void *argp1 = 0 ;
20287 int res1 = 0 ;
20288 int val2 ;
20289 int ecode2 = 0 ;
20290 PyObject * obj0 = 0 ;
20291 PyObject * obj1 = 0 ;
20292 char * kwnames[] = {
20293 (char *) "self",(char *) "col", NULL
20294 };
20295
20296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20298 if (!SWIG_IsOK(res1)) {
20299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20300 }
20301 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20302 ecode2 = SWIG_AsVal_int(obj1, &val2);
20303 if (!SWIG_IsOK(ecode2)) {
20304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20305 }
20306 arg2 = static_cast< int >(val2);
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 (arg1)->SetCol(arg2);
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_Py_Void();
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20321 PyObject *resultobj = 0;
20322 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20323 wxControl *arg2 = (wxControl *) 0 ;
20324 void *argp1 = 0 ;
20325 int res1 = 0 ;
20326 void *argp2 = 0 ;
20327 int res2 = 0 ;
20328 PyObject * obj0 = 0 ;
20329 PyObject * obj1 = 0 ;
20330 char * kwnames[] = {
20331 (char *) "self",(char *) "ctrl", NULL
20332 };
20333
20334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20338 }
20339 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20341 if (!SWIG_IsOK(res2)) {
20342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20343 }
20344 arg2 = reinterpret_cast< wxControl * >(argp2);
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 (arg1)->SetControl(arg2);
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 resultobj = SWIG_Py_Void();
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 PyObject *obj;
20360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20361 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20362 return SWIG_Py_Void();
20363 }
20364
20365 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20366 return SWIG_Python_InitShadowInstance(args);
20367 }
20368
20369 static PyMethodDef SwigMethods[] = {
20370 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20372 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20373 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20374 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20375 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20376 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20377 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20378 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20381 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20382 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20383 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20384 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20385 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20386 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20387 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20388 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20390 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20392 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20394 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20395 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20396 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20397 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20398 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20400 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20401 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20402 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20403 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20404 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20405 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20406 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20407 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20408 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20409 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20411 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20416 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20417 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20423 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20424 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20425 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20426 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20427 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20430 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20431 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20432 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20433 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20434 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20435 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20437 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20438 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20440 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20441 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20442 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20443 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20444 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20445 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20447 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20448 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20449 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20451 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20452 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20453 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20454 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20455 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20458 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20459 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20461 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20462 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20473 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20474 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20475 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20476 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20477 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20478 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20479 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20480 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20481 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20482 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20483 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20484 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20485 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20486 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20489 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20490 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20492 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20493 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20494 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20502 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20503 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20504 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20510 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20511 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20512 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20515 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20517 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20518 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20519 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20532 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20543 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20548 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20549 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20551 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20552 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20553 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20555 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20556 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20558 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20560 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20562 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20564 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20566 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20567 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20568 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20570 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20571 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20573 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20578 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20579 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20580 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20582 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20586 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20587 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20588 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20590 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20592 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20602 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20603 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20604 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20605 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20606 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20609 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20610 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20611 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20612 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20613 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20614 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20615 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20616 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20623 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20624 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20632 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20633 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20638 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20639 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20640 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20641 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20642 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20643 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20644 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20645 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20646 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20647 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20650 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20651 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20654 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20655 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20656 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20672 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20673 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20675 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20676 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20678 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20679 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20681 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20682 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20684 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20685 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20695 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20696 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20698 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20700 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20702 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20704 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20706 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20708 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20722 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20729 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20730 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20744 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20748 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20757 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20758 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20759 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20761 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20762 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20763 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20764 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20765 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20770 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20771 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20780 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20781 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20782 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20783 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20786 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20787 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20791 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20792 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20794 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20795 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20796 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20797 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20798 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20799 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20800 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20801 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20802 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20803 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20804 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20806 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20807 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20808 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20809 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20810 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20811 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20812 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20813 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20814 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20816 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20817 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20818 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20819 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20820 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20821 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20822 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20823 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20824 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20825 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20826 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20827 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20828 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20829 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20831 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20832 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20833 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20837 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20838 { NULL, NULL, 0, NULL }
20839 };
20840
20841
20842 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20843
20844 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20845 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20846 }
20847 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20848 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20849 }
20850 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20851 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20852 }
20853 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20854 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20855 }
20856 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20857 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20858 }
20859 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20860 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20861 }
20862 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20863 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20864 }
20865 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20866 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20867 }
20868 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20869 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20870 }
20871 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20872 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20873 }
20874 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20875 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20876 }
20877 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20878 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20879 }
20880 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20881 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20882 }
20883 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20884 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20885 }
20886 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20887 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20888 }
20889 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20890 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20891 }
20892 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20893 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20894 }
20895 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20896 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20897 }
20898 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20899 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20900 }
20901 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20902 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20903 }
20904 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20905 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20906 }
20907 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20908 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20909 }
20910 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20911 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20912 }
20913 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20914 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20915 }
20916 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20917 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20918 }
20919 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20920 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20921 }
20922 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20923 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20924 }
20925 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20926 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20927 }
20928 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20929 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20930 }
20931 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20932 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20933 }
20934 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20935 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20936 }
20937 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20938 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20939 }
20940 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20941 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20942 }
20943 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20944 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20945 }
20946 static void *_p_wxGridTo_p_wxPanel(void *x) {
20947 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20948 }
20949 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20950 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20951 }
20952 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20953 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20954 }
20955 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20956 return (void *)((wxPanel *) ((wxPyPanel *) x));
20957 }
20958 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20959 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20960 }
20961 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20962 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20963 }
20964 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20965 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20966 }
20967 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20968 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20969 }
20970 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20971 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20972 }
20973 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20974 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20975 }
20976 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20977 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20978 }
20979 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20980 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20981 }
20982 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20983 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20984 }
20985 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20986 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20987 }
20988 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20989 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20990 }
20991 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20992 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20993 }
20994 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20995 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20996 }
20997 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20998 return (void *)((wxWindow *) ((wxMenuBar *) x));
20999 }
21000 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21001 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21002 }
21003 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21004 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21005 }
21006 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21007 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21008 }
21009 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21010 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21011 }
21012 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21013 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21014 }
21015 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21016 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21017 }
21018 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21019 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21020 }
21021 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21022 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21023 }
21024 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21025 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21026 }
21027 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21028 return (void *)((wxWindow *) ((wxPanel *) x));
21029 }
21030 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21031 return (void *)((wxWindow *) ((wxStatusBar *) x));
21032 }
21033 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21034 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21035 }
21036 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21037 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21038 }
21039 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21040 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21041 }
21042 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21043 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21044 }
21045 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21046 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21047 }
21048 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21049 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21050 }
21051 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21052 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21053 }
21054 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21055 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21056 }
21057 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21058 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21059 }
21060 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21061 return (void *)((wxWindow *) ((wxSashWindow *) x));
21062 }
21063 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21064 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21065 }
21066 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21067 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21068 }
21069 static void *_p_wxControlTo_p_wxWindow(void *x) {
21070 return (void *)((wxWindow *) ((wxControl *) x));
21071 }
21072 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21073 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21074 }
21075 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21076 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21077 }
21078 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21079 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21080 }
21081 static void *_p_wxGridTo_p_wxWindow(void *x) {
21082 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21083 }
21084 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21085 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21086 }
21087 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21088 return (void *)((wxWindow *) ((wxPyWindow *) x));
21089 }
21090 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21091 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21092 }
21093 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21094 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21095 }
21096 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21097 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21098 }
21099 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21100 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21101 }
21102 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21103 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21104 }
21105 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21106 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21107 }
21108 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21109 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21110 }
21111 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21112 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21113 }
21114 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21115 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21116 }
21117 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21118 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21119 }
21120 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21121 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21122 }
21123 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21124 return (void *)((wxControl *) ((wxControlWithItems *) x));
21125 }
21126 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21128 }
21129 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21130 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21131 }
21132 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21133 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21134 }
21135 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21136 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21137 }
21138 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21139 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21140 }
21141 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21142 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21143 }
21144 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21145 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21146 }
21147 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21148 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21149 }
21150 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21151 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21152 }
21153 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21154 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21155 }
21156 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21157 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21158 }
21159 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21160 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21161 }
21162 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21163 return (void *)((wxEvent *) ((wxPyEvent *) x));
21164 }
21165 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21166 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21167 }
21168 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21169 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21170 }
21171 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21172 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21173 }
21174 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21175 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21176 }
21177 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21178 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21179 }
21180 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21181 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21182 }
21183 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21184 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21185 }
21186 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21187 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21188 }
21189 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21190 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21191 }
21192 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21193 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21194 }
21195 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21196 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21197 }
21198 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21199 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21200 }
21201 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21202 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21203 }
21204 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21205 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21206 }
21207 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21208 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21209 }
21210 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21212 }
21213 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21214 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21215 }
21216 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21217 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21218 }
21219 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21220 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21221 }
21222 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21223 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21224 }
21225 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21226 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21227 }
21228 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21229 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21230 }
21231 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21232 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21233 }
21234 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21235 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21236 }
21237 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21238 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21239 }
21240 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21242 }
21243 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21244 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21245 }
21246 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21247 return (void *)((wxEvent *) ((wxShowEvent *) x));
21248 }
21249 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21250 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21251 }
21252 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21253 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21254 }
21255 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21257 }
21258 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21259 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21260 }
21261 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21262 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21263 }
21264 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21265 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21266 }
21267 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21268 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21269 }
21270 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21271 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21272 }
21273 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21274 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21275 }
21276 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21277 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21278 }
21279 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21280 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21281 }
21282 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21283 return (void *)((wxObject *) ((wxSizerItem *) x));
21284 }
21285 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21286 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21287 }
21288 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21290 }
21291 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21292 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21293 }
21294 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21295 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21296 }
21297 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21298 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21299 }
21300 static void *_p_wxSizerTo_p_wxObject(void *x) {
21301 return (void *)((wxObject *) ((wxSizer *) x));
21302 }
21303 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21304 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21305 }
21306 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21307 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21308 }
21309 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21310 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21311 }
21312 static void *_p_wxEventTo_p_wxObject(void *x) {
21313 return (void *)((wxObject *) ((wxEvent *) x));
21314 }
21315 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21316 return (void *)((wxObject *) ((wxFontData *) x));
21317 }
21318 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21319 return (void *)((wxObject *) ((wxPrintData *) x));
21320 }
21321 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21322 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21323 }
21324 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21325 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21326 }
21327 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21328 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21329 }
21330 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21331 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21332 }
21333 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21334 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21335 }
21336 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21337 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21338 }
21339 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21340 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21341 }
21342 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21344 }
21345 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21346 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21347 }
21348 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21349 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21350 }
21351 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21352 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21353 }
21354 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21355 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21356 }
21357 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21358 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21359 }
21360 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21361 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21362 }
21363 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21364 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21365 }
21366 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21367 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21368 }
21369 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21370 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21371 }
21372 static void *_p_wxControlTo_p_wxObject(void *x) {
21373 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21374 }
21375 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21376 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21377 }
21378 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21379 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21380 }
21381 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21382 return (void *)((wxObject *) ((wxFSFile *) x));
21383 }
21384 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21385 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21386 }
21387 static void *_p_wxGridTo_p_wxObject(void *x) {
21388 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21389 }
21390 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21391 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21392 }
21393 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21394 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21395 }
21396 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21397 return (void *)((wxObject *) ((wxColourData *) x));
21398 }
21399 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21400 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21401 }
21402 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21403 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21404 }
21405 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21406 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21407 }
21408 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21409 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21410 }
21411 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21412 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21413 }
21414 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21415 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21416 }
21417 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21418 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21419 }
21420 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21421 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21422 }
21423 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21424 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21425 }
21426 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21427 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21428 }
21429 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21430 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21431 }
21432 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21433 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21434 }
21435 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21436 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21437 }
21438 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21439 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21440 }
21441 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21442 return (void *)((wxObject *) ((wxPrinter *) x));
21443 }
21444 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21445 return (void *)((wxObject *) ((wxMenuItem *) x));
21446 }
21447 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21449 }
21450 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21451 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21452 }
21453 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21455 }
21456 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21457 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21458 }
21459 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21460 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21461 }
21462 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21463 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21464 }
21465 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21466 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21467 }
21468 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21469 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21470 }
21471 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21472 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21473 }
21474 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21475 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21476 }
21477 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21478 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21479 }
21480 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21481 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21482 }
21483 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21484 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21485 }
21486 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21487 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21488 }
21489 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21490 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21491 }
21492 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21493 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21494 }
21495 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21496 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21497 }
21498 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21499 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21500 }
21501 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21502 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21503 }
21504 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21505 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21506 }
21507 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21508 return (void *)((wxObject *) ((wxImageHandler *) x));
21509 }
21510 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21511 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21512 }
21513 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21514 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21515 }
21516 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21517 return (void *)((wxObject *) ((wxEvtHandler *) x));
21518 }
21519 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21520 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21521 }
21522 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21523 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21524 }
21525 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21527 }
21528 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21530 }
21531 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21533 }
21534 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21536 }
21537 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21539 }
21540 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21542 }
21543 static void *_p_wxImageTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) ((wxImage *) x));
21545 }
21546 static void *_p_wxFrameTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21548 }
21549 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) ((wxPyPrintout *) x));
21551 }
21552 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21554 }
21555 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21557 }
21558 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21560 }
21561 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21563 }
21564 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21566 }
21567 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21569 }
21570 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21572 }
21573 static void *_p_wxWindowTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21575 }
21576 static void *_p_wxMenuTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21578 }
21579 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21581 }
21582 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21584 }
21585 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21587 }
21588 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21590 }
21591 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21593 }
21594 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21596 }
21597 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21599 }
21600 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21602 }
21603 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21605 }
21606 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21608 }
21609 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21611 }
21612 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21614 }
21615 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21617 }
21618 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21620 }
21621 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) ((wxPrintPreview *) x));
21623 }
21624 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21626 }
21627 static void *_p_wxPanelTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21629 }
21630 static void *_p_wxDialogTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21632 }
21633 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21635 }
21636 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21638 }
21639 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21641 }
21642 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21644 }
21645 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) ((wxPrintDialog *) x));
21647 }
21648 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) ((wxFileSystem *) x));
21650 }
21651 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21653 }
21654 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21656 }
21657 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21659 }
21660 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21661 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21662 }
21663 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21664 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21665 }
21666 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21667 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21668 }
21669 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21670 return (void *)((wxObject *) ((wxGridTableBase *) x));
21671 }
21672 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21673 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21674 }
21675 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21676 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21677 }
21678 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21679 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21680 }
21681 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21682 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21683 }
21684 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21685 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21686 }
21687 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21688 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21689 }
21690 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21691 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21692 }
21693 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21695 }
21696 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21697 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21698 }
21699 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21700 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21701 }
21702 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21703 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21704 }
21705 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21706 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21707 }
21708 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21709 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21710 }
21711 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21712 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21713 }
21714 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21715 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21716 }
21717 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21718 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21719 }
21720 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21721 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21722 }
21723 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21724 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21725 }
21726 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21727 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21728 }
21729 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21730 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21731 }
21732 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21733 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21734 }
21735 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21736 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21737 }
21738 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21739 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21740 }
21741 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21742 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21743 }
21744 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21745 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21746 }
21747 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
21748 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21749 }
21750 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21751 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21752 }
21753 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21754 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21755 }
21756 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21757 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21758 }
21759 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21760 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21761 }
21762 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21763 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21764 }
21765 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21766 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21767 }
21768 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21769 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21770 }
21771 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21772 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21773 }
21774 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21775 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21776 }
21777 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21778 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21779 }
21780 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21781 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21782 }
21783 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21784 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21785 }
21786 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21787 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21788 }
21789 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21790 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21791 }
21792 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21793 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21794 }
21795 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21796 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21797 }
21798 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21799 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21800 }
21801 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21802 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21803 }
21804 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21805 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21806 }
21807 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21808 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21809 }
21810 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21811 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21812 }
21813 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21814 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21815 }
21816 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21817 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21818 }
21819 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21820 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21821 }
21822 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21823 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21824 }
21825 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21826 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21827 }
21828 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21829 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21830 }
21831 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21832 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21833 }
21834 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21835 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21836 }
21837 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21838 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21839 }
21840 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21841 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21842 }
21843 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21844 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21845 }
21846 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21847 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21848 }
21849 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21850 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21851 }
21852 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21853 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21854 }
21855 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21856 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21857 }
21858 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21859 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21860 }
21861 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21862 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21863 }
21864 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21865 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21866 }
21867 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21868 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21869 }
21870 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21871 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21872 }
21873 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21874 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21875 }
21876 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21877 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21878 }
21879 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21880 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21881 }
21882 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21883 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21884 }
21885 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21886 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21887 }
21888 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21889 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21890 }
21891 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21892 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21893 }
21894 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21895 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21896 }
21897 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21898 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21899 }
21900 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21901 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21902 }
21903 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21904 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21905 }
21906 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21907 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21908 }
21909 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21910 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21911 }
21912 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21913 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21914 }
21915 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21916 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21917 }
21918 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21919 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21920 }
21921 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21922 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21923 }
21924 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21925 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21926 }
21927 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21928 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21929 }
21930 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21931 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21932 }
21933 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21934 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21935 }
21936 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21937 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21938 }
21939 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21940 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21941 }
21942 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21943 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21944 }
21945 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21946 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21947 }
21948 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21949 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21950 }
21951 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21952 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21953 }
21954 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21955 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21956 }
21957 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21958 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21959 }
21960 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21961 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};
21962 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21963 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21964 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21965 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21966 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21967 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21968 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21969 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21970 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21971 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21972 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21973 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21974 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21975 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21976 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21978 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21979 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21980 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21983 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21985 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21986 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21987 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21993 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21994 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
21995 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21996 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21997 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21998 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21999 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22000 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22001 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22002 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22003 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22004 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22005 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22006 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22007 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22008 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22009 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22010 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22011 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22012 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22013 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22014 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22015 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22016 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22017 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22018 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22019 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22020 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22021 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22022 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22023 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22024 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22025 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22026 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22027 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22028 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22029 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22030 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22031 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22032 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22033 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22034 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22035 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22036 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22037 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22038 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22039 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22040 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22041 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22042 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22043 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22044 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22045 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22046 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22047 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22048 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22049 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22050 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22051 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22052 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22053 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22054 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22055 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22056 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22057 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22058 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22059 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22060 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22061 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22062 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22063 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22064 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22065 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22066 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22067 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22068 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22069 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22070 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22071 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22072 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22073 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22074 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22075 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22076 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22077 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22078 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22079 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22080 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22081 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22082 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22083 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22084 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22085 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22086 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22087 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22088 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22089 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22090 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22091 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22092 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22093 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22094 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22095 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22096 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22097 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22098 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22099 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22100 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22101 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22102 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22103 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22104 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22105 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22106 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22107 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22108 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22109 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22110 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22111 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22112 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22113 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22114 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22115 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22116 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22117 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22118 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22119 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22120 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22121 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22122 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22123 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22124 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22125 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22126 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22127 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22128 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22129 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22130 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22131 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22132 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22133 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22134 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22135 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22136 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22137 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22138 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22139 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22140 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22141 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22142 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22143 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22144 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22145 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22146 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22147 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22148 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22149 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22150
22151 static swig_type_info *swig_type_initial[] = {
22152 &_swigt__p_char,
22153 &_swigt__p_form_ops_t,
22154 &_swigt__p_int,
22155 &_swigt__p_long,
22156 &_swigt__p_unsigned_char,
22157 &_swigt__p_unsigned_int,
22158 &_swigt__p_unsigned_long,
22159 &_swigt__p_wxANIHandler,
22160 &_swigt__p_wxAcceleratorTable,
22161 &_swigt__p_wxActivateEvent,
22162 &_swigt__p_wxArrayString,
22163 &_swigt__p_wxBMPHandler,
22164 &_swigt__p_wxBoxSizer,
22165 &_swigt__p_wxCURHandler,
22166 &_swigt__p_wxCalculateLayoutEvent,
22167 &_swigt__p_wxChildFocusEvent,
22168 &_swigt__p_wxClipboardTextEvent,
22169 &_swigt__p_wxCloseEvent,
22170 &_swigt__p_wxColour,
22171 &_swigt__p_wxColourData,
22172 &_swigt__p_wxColourDialog,
22173 &_swigt__p_wxCommandEvent,
22174 &_swigt__p_wxContextMenuEvent,
22175 &_swigt__p_wxControl,
22176 &_swigt__p_wxControlWithItems,
22177 &_swigt__p_wxDC,
22178 &_swigt__p_wxDateEvent,
22179 &_swigt__p_wxDialog,
22180 &_swigt__p_wxDirDialog,
22181 &_swigt__p_wxDisplayChangedEvent,
22182 &_swigt__p_wxDropFilesEvent,
22183 &_swigt__p_wxDuplexMode,
22184 &_swigt__p_wxEraseEvent,
22185 &_swigt__p_wxEvent,
22186 &_swigt__p_wxEvtHandler,
22187 &_swigt__p_wxFSFile,
22188 &_swigt__p_wxFileDialog,
22189 &_swigt__p_wxFileSystem,
22190 &_swigt__p_wxFindDialogEvent,
22191 &_swigt__p_wxFindReplaceData,
22192 &_swigt__p_wxFindReplaceDialog,
22193 &_swigt__p_wxFlexGridSizer,
22194 &_swigt__p_wxFocusEvent,
22195 &_swigt__p_wxFont,
22196 &_swigt__p_wxFontData,
22197 &_swigt__p_wxFontDialog,
22198 &_swigt__p_wxFrame,
22199 &_swigt__p_wxGBSizerItem,
22200 &_swigt__p_wxGIFHandler,
22201 &_swigt__p_wxGrid,
22202 &_swigt__p_wxGridBagSizer,
22203 &_swigt__p_wxGridCellAttr,
22204 &_swigt__p_wxGridCellAttrProvider,
22205 &_swigt__p_wxGridCellAutoWrapStringEditor,
22206 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22207 &_swigt__p_wxGridCellBoolEditor,
22208 &_swigt__p_wxGridCellBoolRenderer,
22209 &_swigt__p_wxGridCellChoiceEditor,
22210 &_swigt__p_wxGridCellCoords,
22211 &_swigt__p_wxGridCellDateTimeRenderer,
22212 &_swigt__p_wxGridCellEditor,
22213 &_swigt__p_wxGridCellEnumEditor,
22214 &_swigt__p_wxGridCellEnumRenderer,
22215 &_swigt__p_wxGridCellFloatEditor,
22216 &_swigt__p_wxGridCellFloatRenderer,
22217 &_swigt__p_wxGridCellNumberEditor,
22218 &_swigt__p_wxGridCellNumberRenderer,
22219 &_swigt__p_wxGridCellRenderer,
22220 &_swigt__p_wxGridCellStringRenderer,
22221 &_swigt__p_wxGridCellTextEditor,
22222 &_swigt__p_wxGridCellWorker,
22223 &_swigt__p_wxGridEditorCreatedEvent,
22224 &_swigt__p_wxGridEvent,
22225 &_swigt__p_wxGridRangeSelectEvent,
22226 &_swigt__p_wxGridSizeEvent,
22227 &_swigt__p_wxGridSizer,
22228 &_swigt__p_wxGridStringTable,
22229 &_swigt__p_wxGridTableBase,
22230 &_swigt__p_wxGridTableMessage,
22231 &_swigt__p_wxICOHandler,
22232 &_swigt__p_wxIconizeEvent,
22233 &_swigt__p_wxIdleEvent,
22234 &_swigt__p_wxImage,
22235 &_swigt__p_wxImageHandler,
22236 &_swigt__p_wxIndividualLayoutConstraint,
22237 &_swigt__p_wxInitDialogEvent,
22238 &_swigt__p_wxJPEGHandler,
22239 &_swigt__p_wxKeyEvent,
22240 &_swigt__p_wxLayoutAlgorithm,
22241 &_swigt__p_wxLayoutConstraints,
22242 &_swigt__p_wxMDIChildFrame,
22243 &_swigt__p_wxMDIClientWindow,
22244 &_swigt__p_wxMDIParentFrame,
22245 &_swigt__p_wxMaximizeEvent,
22246 &_swigt__p_wxMenu,
22247 &_swigt__p_wxMenuBar,
22248 &_swigt__p_wxMenuEvent,
22249 &_swigt__p_wxMenuItem,
22250 &_swigt__p_wxMessageDialog,
22251 &_swigt__p_wxMiniFrame,
22252 &_swigt__p_wxMouseCaptureChangedEvent,
22253 &_swigt__p_wxMouseCaptureLostEvent,
22254 &_swigt__p_wxMouseEvent,
22255 &_swigt__p_wxMoveEvent,
22256 &_swigt__p_wxMultiChoiceDialog,
22257 &_swigt__p_wxNavigationKeyEvent,
22258 &_swigt__p_wxNcPaintEvent,
22259 &_swigt__p_wxNotifyEvent,
22260 &_swigt__p_wxNumberEntryDialog,
22261 &_swigt__p_wxObject,
22262 &_swigt__p_wxPCXHandler,
22263 &_swigt__p_wxPNGHandler,
22264 &_swigt__p_wxPNMHandler,
22265 &_swigt__p_wxPageSetupDialog,
22266 &_swigt__p_wxPageSetupDialogData,
22267 &_swigt__p_wxPaintEvent,
22268 &_swigt__p_wxPaletteChangedEvent,
22269 &_swigt__p_wxPanel,
22270 &_swigt__p_wxPaperSize,
22271 &_swigt__p_wxPasswordEntryDialog,
22272 &_swigt__p_wxPen,
22273 &_swigt__p_wxPoint,
22274 &_swigt__p_wxPopupWindow,
22275 &_swigt__p_wxPreviewCanvas,
22276 &_swigt__p_wxPreviewControlBar,
22277 &_swigt__p_wxPreviewFrame,
22278 &_swigt__p_wxPrintData,
22279 &_swigt__p_wxPrintDialog,
22280 &_swigt__p_wxPrintDialogData,
22281 &_swigt__p_wxPrintPreview,
22282 &_swigt__p_wxPrinter,
22283 &_swigt__p_wxProgressDialog,
22284 &_swigt__p_wxPyApp,
22285 &_swigt__p_wxPyCommandEvent,
22286 &_swigt__p_wxPyEvent,
22287 &_swigt__p_wxPyGridCellAttrProvider,
22288 &_swigt__p_wxPyGridCellEditor,
22289 &_swigt__p_wxPyGridCellRenderer,
22290 &_swigt__p_wxPyGridTableBase,
22291 &_swigt__p_wxPyHtmlListBox,
22292 &_swigt__p_wxPyImageHandler,
22293 &_swigt__p_wxPyPanel,
22294 &_swigt__p_wxPyPopupTransientWindow,
22295 &_swigt__p_wxPyPreviewControlBar,
22296 &_swigt__p_wxPyPreviewFrame,
22297 &_swigt__p_wxPyPrintPreview,
22298 &_swigt__p_wxPyPrintout,
22299 &_swigt__p_wxPyScrolledWindow,
22300 &_swigt__p_wxPySizer,
22301 &_swigt__p_wxPyTaskBarIcon,
22302 &_swigt__p_wxPyVListBox,
22303 &_swigt__p_wxPyVScrolledWindow,
22304 &_swigt__p_wxPyValidator,
22305 &_swigt__p_wxPyWindow,
22306 &_swigt__p_wxQueryLayoutInfoEvent,
22307 &_swigt__p_wxQueryNewPaletteEvent,
22308 &_swigt__p_wxRect,
22309 &_swigt__p_wxSashEvent,
22310 &_swigt__p_wxSashLayoutWindow,
22311 &_swigt__p_wxSashWindow,
22312 &_swigt__p_wxScrollEvent,
22313 &_swigt__p_wxScrollWinEvent,
22314 &_swigt__p_wxScrolledWindow,
22315 &_swigt__p_wxSetCursorEvent,
22316 &_swigt__p_wxShowEvent,
22317 &_swigt__p_wxSingleChoiceDialog,
22318 &_swigt__p_wxSizeEvent,
22319 &_swigt__p_wxSizer,
22320 &_swigt__p_wxSizerItem,
22321 &_swigt__p_wxSplashScreen,
22322 &_swigt__p_wxSplashScreenWindow,
22323 &_swigt__p_wxSplitterEvent,
22324 &_swigt__p_wxSplitterWindow,
22325 &_swigt__p_wxStaticBoxSizer,
22326 &_swigt__p_wxStatusBar,
22327 &_swigt__p_wxStdDialogButtonSizer,
22328 &_swigt__p_wxString,
22329 &_swigt__p_wxSysColourChangedEvent,
22330 &_swigt__p_wxTIFFHandler,
22331 &_swigt__p_wxTaskBarIconEvent,
22332 &_swigt__p_wxTextEntryDialog,
22333 &_swigt__p_wxTipWindow,
22334 &_swigt__p_wxTopLevelWindow,
22335 &_swigt__p_wxUpdateUIEvent,
22336 &_swigt__p_wxValidator,
22337 &_swigt__p_wxVisualAttributes,
22338 &_swigt__p_wxWindow,
22339 &_swigt__p_wxWindowCreateEvent,
22340 &_swigt__p_wxWindowDestroyEvent,
22341 &_swigt__p_wxXPMHandler,
22342 };
22343
22344 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22345 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22346 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22351 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22352 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22354 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22355 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22356 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22357 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22358 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22359 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22365 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}};
22366 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22367 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}};
22368 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22375 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22376 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22379 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22380 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22381 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22382 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22383 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22384 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22385 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22386 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22387 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22388 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22389 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22390 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22391 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22393 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22394 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22395 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22396 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22397 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22398 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22399 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}};
22400 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22401 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22402 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22403 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22404 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22405 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22406 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22407 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22408 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22409 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22410 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22411 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22412 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22413 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22414 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22415 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22416 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22417 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22418 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22419 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22420 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22421 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22422 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22423 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22424 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22425 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22426 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22427 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22428 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22429 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22430 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22431 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22432 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22433 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22434 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22435 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22436 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22437 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22438 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22439 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22440 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22441 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22442 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22443 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22444 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22445 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22446 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22447 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22448 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22449 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}};
22450 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22451 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22452 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22453 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22454 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}};
22455 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22456 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22457 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}};
22458 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22459 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22460 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22461 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22462 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22463 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22464 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}};
22465 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}};
22466 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}};
22467 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}};
22468 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22469 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22470 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22471 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22472 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22473 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}};
22474 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22475 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22476 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}};
22477 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22478 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22479 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22480 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22481 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22482 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22483 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22484 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22485 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22486 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22487 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22488 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22489 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22490 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22491 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22492 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22493 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22494 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22495 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22496 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22497 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22498 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22499 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22500 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22501 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22502 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22503 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22504 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22505 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22506 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22507 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22508 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22509 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22510 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22511 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22512 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22513 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22514 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22515 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22516 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22517 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22518 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22519 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22520 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22521 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22522 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22523 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22524 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22525 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22526 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22527 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22528 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22529 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22530 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}};
22531 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22532 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22533 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22534
22535 static swig_cast_info *swig_cast_initial[] = {
22536 _swigc__p_char,
22537 _swigc__p_form_ops_t,
22538 _swigc__p_int,
22539 _swigc__p_long,
22540 _swigc__p_unsigned_char,
22541 _swigc__p_unsigned_int,
22542 _swigc__p_unsigned_long,
22543 _swigc__p_wxANIHandler,
22544 _swigc__p_wxAcceleratorTable,
22545 _swigc__p_wxActivateEvent,
22546 _swigc__p_wxArrayString,
22547 _swigc__p_wxBMPHandler,
22548 _swigc__p_wxBoxSizer,
22549 _swigc__p_wxCURHandler,
22550 _swigc__p_wxCalculateLayoutEvent,
22551 _swigc__p_wxChildFocusEvent,
22552 _swigc__p_wxClipboardTextEvent,
22553 _swigc__p_wxCloseEvent,
22554 _swigc__p_wxColour,
22555 _swigc__p_wxColourData,
22556 _swigc__p_wxColourDialog,
22557 _swigc__p_wxCommandEvent,
22558 _swigc__p_wxContextMenuEvent,
22559 _swigc__p_wxControl,
22560 _swigc__p_wxControlWithItems,
22561 _swigc__p_wxDC,
22562 _swigc__p_wxDateEvent,
22563 _swigc__p_wxDialog,
22564 _swigc__p_wxDirDialog,
22565 _swigc__p_wxDisplayChangedEvent,
22566 _swigc__p_wxDropFilesEvent,
22567 _swigc__p_wxDuplexMode,
22568 _swigc__p_wxEraseEvent,
22569 _swigc__p_wxEvent,
22570 _swigc__p_wxEvtHandler,
22571 _swigc__p_wxFSFile,
22572 _swigc__p_wxFileDialog,
22573 _swigc__p_wxFileSystem,
22574 _swigc__p_wxFindDialogEvent,
22575 _swigc__p_wxFindReplaceData,
22576 _swigc__p_wxFindReplaceDialog,
22577 _swigc__p_wxFlexGridSizer,
22578 _swigc__p_wxFocusEvent,
22579 _swigc__p_wxFont,
22580 _swigc__p_wxFontData,
22581 _swigc__p_wxFontDialog,
22582 _swigc__p_wxFrame,
22583 _swigc__p_wxGBSizerItem,
22584 _swigc__p_wxGIFHandler,
22585 _swigc__p_wxGrid,
22586 _swigc__p_wxGridBagSizer,
22587 _swigc__p_wxGridCellAttr,
22588 _swigc__p_wxGridCellAttrProvider,
22589 _swigc__p_wxGridCellAutoWrapStringEditor,
22590 _swigc__p_wxGridCellAutoWrapStringRenderer,
22591 _swigc__p_wxGridCellBoolEditor,
22592 _swigc__p_wxGridCellBoolRenderer,
22593 _swigc__p_wxGridCellChoiceEditor,
22594 _swigc__p_wxGridCellCoords,
22595 _swigc__p_wxGridCellDateTimeRenderer,
22596 _swigc__p_wxGridCellEditor,
22597 _swigc__p_wxGridCellEnumEditor,
22598 _swigc__p_wxGridCellEnumRenderer,
22599 _swigc__p_wxGridCellFloatEditor,
22600 _swigc__p_wxGridCellFloatRenderer,
22601 _swigc__p_wxGridCellNumberEditor,
22602 _swigc__p_wxGridCellNumberRenderer,
22603 _swigc__p_wxGridCellRenderer,
22604 _swigc__p_wxGridCellStringRenderer,
22605 _swigc__p_wxGridCellTextEditor,
22606 _swigc__p_wxGridCellWorker,
22607 _swigc__p_wxGridEditorCreatedEvent,
22608 _swigc__p_wxGridEvent,
22609 _swigc__p_wxGridRangeSelectEvent,
22610 _swigc__p_wxGridSizeEvent,
22611 _swigc__p_wxGridSizer,
22612 _swigc__p_wxGridStringTable,
22613 _swigc__p_wxGridTableBase,
22614 _swigc__p_wxGridTableMessage,
22615 _swigc__p_wxICOHandler,
22616 _swigc__p_wxIconizeEvent,
22617 _swigc__p_wxIdleEvent,
22618 _swigc__p_wxImage,
22619 _swigc__p_wxImageHandler,
22620 _swigc__p_wxIndividualLayoutConstraint,
22621 _swigc__p_wxInitDialogEvent,
22622 _swigc__p_wxJPEGHandler,
22623 _swigc__p_wxKeyEvent,
22624 _swigc__p_wxLayoutAlgorithm,
22625 _swigc__p_wxLayoutConstraints,
22626 _swigc__p_wxMDIChildFrame,
22627 _swigc__p_wxMDIClientWindow,
22628 _swigc__p_wxMDIParentFrame,
22629 _swigc__p_wxMaximizeEvent,
22630 _swigc__p_wxMenu,
22631 _swigc__p_wxMenuBar,
22632 _swigc__p_wxMenuEvent,
22633 _swigc__p_wxMenuItem,
22634 _swigc__p_wxMessageDialog,
22635 _swigc__p_wxMiniFrame,
22636 _swigc__p_wxMouseCaptureChangedEvent,
22637 _swigc__p_wxMouseCaptureLostEvent,
22638 _swigc__p_wxMouseEvent,
22639 _swigc__p_wxMoveEvent,
22640 _swigc__p_wxMultiChoiceDialog,
22641 _swigc__p_wxNavigationKeyEvent,
22642 _swigc__p_wxNcPaintEvent,
22643 _swigc__p_wxNotifyEvent,
22644 _swigc__p_wxNumberEntryDialog,
22645 _swigc__p_wxObject,
22646 _swigc__p_wxPCXHandler,
22647 _swigc__p_wxPNGHandler,
22648 _swigc__p_wxPNMHandler,
22649 _swigc__p_wxPageSetupDialog,
22650 _swigc__p_wxPageSetupDialogData,
22651 _swigc__p_wxPaintEvent,
22652 _swigc__p_wxPaletteChangedEvent,
22653 _swigc__p_wxPanel,
22654 _swigc__p_wxPaperSize,
22655 _swigc__p_wxPasswordEntryDialog,
22656 _swigc__p_wxPen,
22657 _swigc__p_wxPoint,
22658 _swigc__p_wxPopupWindow,
22659 _swigc__p_wxPreviewCanvas,
22660 _swigc__p_wxPreviewControlBar,
22661 _swigc__p_wxPreviewFrame,
22662 _swigc__p_wxPrintData,
22663 _swigc__p_wxPrintDialog,
22664 _swigc__p_wxPrintDialogData,
22665 _swigc__p_wxPrintPreview,
22666 _swigc__p_wxPrinter,
22667 _swigc__p_wxProgressDialog,
22668 _swigc__p_wxPyApp,
22669 _swigc__p_wxPyCommandEvent,
22670 _swigc__p_wxPyEvent,
22671 _swigc__p_wxPyGridCellAttrProvider,
22672 _swigc__p_wxPyGridCellEditor,
22673 _swigc__p_wxPyGridCellRenderer,
22674 _swigc__p_wxPyGridTableBase,
22675 _swigc__p_wxPyHtmlListBox,
22676 _swigc__p_wxPyImageHandler,
22677 _swigc__p_wxPyPanel,
22678 _swigc__p_wxPyPopupTransientWindow,
22679 _swigc__p_wxPyPreviewControlBar,
22680 _swigc__p_wxPyPreviewFrame,
22681 _swigc__p_wxPyPrintPreview,
22682 _swigc__p_wxPyPrintout,
22683 _swigc__p_wxPyScrolledWindow,
22684 _swigc__p_wxPySizer,
22685 _swigc__p_wxPyTaskBarIcon,
22686 _swigc__p_wxPyVListBox,
22687 _swigc__p_wxPyVScrolledWindow,
22688 _swigc__p_wxPyValidator,
22689 _swigc__p_wxPyWindow,
22690 _swigc__p_wxQueryLayoutInfoEvent,
22691 _swigc__p_wxQueryNewPaletteEvent,
22692 _swigc__p_wxRect,
22693 _swigc__p_wxSashEvent,
22694 _swigc__p_wxSashLayoutWindow,
22695 _swigc__p_wxSashWindow,
22696 _swigc__p_wxScrollEvent,
22697 _swigc__p_wxScrollWinEvent,
22698 _swigc__p_wxScrolledWindow,
22699 _swigc__p_wxSetCursorEvent,
22700 _swigc__p_wxShowEvent,
22701 _swigc__p_wxSingleChoiceDialog,
22702 _swigc__p_wxSizeEvent,
22703 _swigc__p_wxSizer,
22704 _swigc__p_wxSizerItem,
22705 _swigc__p_wxSplashScreen,
22706 _swigc__p_wxSplashScreenWindow,
22707 _swigc__p_wxSplitterEvent,
22708 _swigc__p_wxSplitterWindow,
22709 _swigc__p_wxStaticBoxSizer,
22710 _swigc__p_wxStatusBar,
22711 _swigc__p_wxStdDialogButtonSizer,
22712 _swigc__p_wxString,
22713 _swigc__p_wxSysColourChangedEvent,
22714 _swigc__p_wxTIFFHandler,
22715 _swigc__p_wxTaskBarIconEvent,
22716 _swigc__p_wxTextEntryDialog,
22717 _swigc__p_wxTipWindow,
22718 _swigc__p_wxTopLevelWindow,
22719 _swigc__p_wxUpdateUIEvent,
22720 _swigc__p_wxValidator,
22721 _swigc__p_wxVisualAttributes,
22722 _swigc__p_wxWindow,
22723 _swigc__p_wxWindowCreateEvent,
22724 _swigc__p_wxWindowDestroyEvent,
22725 _swigc__p_wxXPMHandler,
22726 };
22727
22728
22729 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22730
22731 static swig_const_info swig_const_table[] = {
22732 {0, 0, 0, 0.0, 0, 0}};
22733
22734 #ifdef __cplusplus
22735 }
22736 #endif
22737 /* -----------------------------------------------------------------------------
22738 * Type initialization:
22739 * This problem is tough by the requirement that no dynamic
22740 * memory is used. Also, since swig_type_info structures store pointers to
22741 * swig_cast_info structures and swig_cast_info structures store pointers back
22742 * to swig_type_info structures, we need some lookup code at initialization.
22743 * The idea is that swig generates all the structures that are needed.
22744 * The runtime then collects these partially filled structures.
22745 * The SWIG_InitializeModule function takes these initial arrays out of
22746 * swig_module, and does all the lookup, filling in the swig_module.types
22747 * array with the correct data and linking the correct swig_cast_info
22748 * structures together.
22749 *
22750 * The generated swig_type_info structures are assigned staticly to an initial
22751 * array. We just loop though that array, and handle each type individually.
22752 * First we lookup if this type has been already loaded, and if so, use the
22753 * loaded structure instead of the generated one. Then we have to fill in the
22754 * cast linked list. The cast data is initially stored in something like a
22755 * two-dimensional array. Each row corresponds to a type (there are the same
22756 * number of rows as there are in the swig_type_initial array). Each entry in
22757 * a column is one of the swig_cast_info structures for that type.
22758 * The cast_initial array is actually an array of arrays, because each row has
22759 * a variable number of columns. So to actually build the cast linked list,
22760 * we find the array of casts associated with the type, and loop through it
22761 * adding the casts to the list. The one last trick we need to do is making
22762 * sure the type pointer in the swig_cast_info struct is correct.
22763 *
22764 * First off, we lookup the cast->type name to see if it is already loaded.
22765 * There are three cases to handle:
22766 * 1) If the cast->type has already been loaded AND the type we are adding
22767 * casting info to has not been loaded (it is in this module), THEN we
22768 * replace the cast->type pointer with the type pointer that has already
22769 * been loaded.
22770 * 2) If BOTH types (the one we are adding casting info to, and the
22771 * cast->type) are loaded, THEN the cast info has already been loaded by
22772 * the previous module so we just ignore it.
22773 * 3) Finally, if cast->type has not already been loaded, then we add that
22774 * swig_cast_info to the linked list (because the cast->type) pointer will
22775 * be correct.
22776 * ----------------------------------------------------------------------------- */
22777
22778 #ifdef __cplusplus
22779 extern "C" {
22780 #if 0
22781 } /* c-mode */
22782 #endif
22783 #endif
22784
22785 #if 0
22786 #define SWIGRUNTIME_DEBUG
22787 #endif
22788
22789 SWIGRUNTIME void
22790 SWIG_InitializeModule(void *clientdata) {
22791 size_t i;
22792 swig_module_info *module_head;
22793 static int init_run = 0;
22794
22795 clientdata = clientdata;
22796
22797 if (init_run) return;
22798 init_run = 1;
22799
22800 /* Initialize the swig_module */
22801 swig_module.type_initial = swig_type_initial;
22802 swig_module.cast_initial = swig_cast_initial;
22803
22804 /* Try and load any already created modules */
22805 module_head = SWIG_GetModule(clientdata);
22806 if (module_head) {
22807 swig_module.next = module_head->next;
22808 module_head->next = &swig_module;
22809 } else {
22810 /* This is the first module loaded */
22811 swig_module.next = &swig_module;
22812 SWIG_SetModule(clientdata, &swig_module);
22813 }
22814
22815 /* Now work on filling in swig_module.types */
22816 #ifdef SWIGRUNTIME_DEBUG
22817 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22818 #endif
22819 for (i = 0; i < swig_module.size; ++i) {
22820 swig_type_info *type = 0;
22821 swig_type_info *ret;
22822 swig_cast_info *cast;
22823
22824 #ifdef SWIGRUNTIME_DEBUG
22825 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22826 #endif
22827
22828 /* if there is another module already loaded */
22829 if (swig_module.next != &swig_module) {
22830 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22831 }
22832 if (type) {
22833 /* Overwrite clientdata field */
22834 #ifdef SWIGRUNTIME_DEBUG
22835 printf("SWIG_InitializeModule: found type %s\n", type->name);
22836 #endif
22837 if (swig_module.type_initial[i]->clientdata) {
22838 type->clientdata = swig_module.type_initial[i]->clientdata;
22839 #ifdef SWIGRUNTIME_DEBUG
22840 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22841 #endif
22842 }
22843 } else {
22844 type = swig_module.type_initial[i];
22845 }
22846
22847 /* Insert casting types */
22848 cast = swig_module.cast_initial[i];
22849 while (cast->type) {
22850 /* Don't need to add information already in the list */
22851 ret = 0;
22852 #ifdef SWIGRUNTIME_DEBUG
22853 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22854 #endif
22855 if (swig_module.next != &swig_module) {
22856 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22857 #ifdef SWIGRUNTIME_DEBUG
22858 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22859 #endif
22860 }
22861 if (ret) {
22862 if (type == swig_module.type_initial[i]) {
22863 #ifdef SWIGRUNTIME_DEBUG
22864 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22865 #endif
22866 cast->type = ret;
22867 ret = 0;
22868 } else {
22869 /* Check for casting already in the list */
22870 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22871 #ifdef SWIGRUNTIME_DEBUG
22872 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22873 #endif
22874 if (!ocast) ret = 0;
22875 }
22876 }
22877
22878 if (!ret) {
22879 #ifdef SWIGRUNTIME_DEBUG
22880 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22881 #endif
22882 if (type->cast) {
22883 type->cast->prev = cast;
22884 cast->next = type->cast;
22885 }
22886 type->cast = cast;
22887 }
22888 cast++;
22889 }
22890 /* Set entry in modules->types array equal to the type */
22891 swig_module.types[i] = type;
22892 }
22893 swig_module.types[i] = 0;
22894
22895 #ifdef SWIGRUNTIME_DEBUG
22896 printf("**** SWIG_InitializeModule: Cast List ******\n");
22897 for (i = 0; i < swig_module.size; ++i) {
22898 int j = 0;
22899 swig_cast_info *cast = swig_module.cast_initial[i];
22900 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22901 while (cast->type) {
22902 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22903 cast++;
22904 ++j;
22905 }
22906 printf("---- Total casts: %d\n",j);
22907 }
22908 printf("**** SWIG_InitializeModule: Cast List ******\n");
22909 #endif
22910 }
22911
22912 /* This function will propagate the clientdata field of type to
22913 * any new swig_type_info structures that have been added into the list
22914 * of equivalent types. It is like calling
22915 * SWIG_TypeClientData(type, clientdata) a second time.
22916 */
22917 SWIGRUNTIME void
22918 SWIG_PropagateClientData(void) {
22919 size_t i;
22920 swig_cast_info *equiv;
22921 static int init_run = 0;
22922
22923 if (init_run) return;
22924 init_run = 1;
22925
22926 for (i = 0; i < swig_module.size; i++) {
22927 if (swig_module.types[i]->clientdata) {
22928 equiv = swig_module.types[i]->cast;
22929 while (equiv) {
22930 if (!equiv->converter) {
22931 if (equiv->type && !equiv->type->clientdata)
22932 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22933 }
22934 equiv = equiv->next;
22935 }
22936 }
22937 }
22938 }
22939
22940 #ifdef __cplusplus
22941 #if 0
22942 {
22943 /* c-mode */
22944 #endif
22945 }
22946 #endif
22947
22948
22949
22950 #ifdef __cplusplus
22951 extern "C" {
22952 #endif
22953
22954 /* Python-specific SWIG API */
22955 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22956 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22957 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22958
22959 /* -----------------------------------------------------------------------------
22960 * global variable support code.
22961 * ----------------------------------------------------------------------------- */
22962
22963 typedef struct swig_globalvar {
22964 char *name; /* Name of global variable */
22965 PyObject *(*get_attr)(void); /* Return the current value */
22966 int (*set_attr)(PyObject *); /* Set the value */
22967 struct swig_globalvar *next;
22968 } swig_globalvar;
22969
22970 typedef struct swig_varlinkobject {
22971 PyObject_HEAD
22972 swig_globalvar *vars;
22973 } swig_varlinkobject;
22974
22975 SWIGINTERN PyObject *
22976 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22977 return PyString_FromString("<Swig global variables>");
22978 }
22979
22980 SWIGINTERN PyObject *
22981 swig_varlink_str(swig_varlinkobject *v) {
22982 PyObject *str = PyString_FromString("(");
22983 swig_globalvar *var;
22984 for (var = v->vars; var; var=var->next) {
22985 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22986 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22987 }
22988 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22989 return str;
22990 }
22991
22992 SWIGINTERN int
22993 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22994 PyObject *str = swig_varlink_str(v);
22995 fprintf(fp,"Swig global variables ");
22996 fprintf(fp,"%s\n", PyString_AsString(str));
22997 Py_DECREF(str);
22998 return 0;
22999 }
23000
23001 SWIGINTERN void
23002 swig_varlink_dealloc(swig_varlinkobject *v) {
23003 swig_globalvar *var = v->vars;
23004 while (var) {
23005 swig_globalvar *n = var->next;
23006 free(var->name);
23007 free(var);
23008 var = n;
23009 }
23010 }
23011
23012 SWIGINTERN PyObject *
23013 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23014 PyObject *res = NULL;
23015 swig_globalvar *var = v->vars;
23016 while (var) {
23017 if (strcmp(var->name,n) == 0) {
23018 res = (*var->get_attr)();
23019 break;
23020 }
23021 var = var->next;
23022 }
23023 if (res == NULL && !PyErr_Occurred()) {
23024 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23025 }
23026 return res;
23027 }
23028
23029 SWIGINTERN int
23030 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23031 int res = 1;
23032 swig_globalvar *var = v->vars;
23033 while (var) {
23034 if (strcmp(var->name,n) == 0) {
23035 res = (*var->set_attr)(p);
23036 break;
23037 }
23038 var = var->next;
23039 }
23040 if (res == 1 && !PyErr_Occurred()) {
23041 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23042 }
23043 return res;
23044 }
23045
23046 SWIGINTERN PyTypeObject*
23047 swig_varlink_type(void) {
23048 static char varlink__doc__[] = "Swig var link object";
23049 static PyTypeObject varlink_type;
23050 static int type_init = 0;
23051 if (!type_init) {
23052 const PyTypeObject tmp
23053 = {
23054 PyObject_HEAD_INIT(NULL)
23055 0, /* Number of items in variable part (ob_size) */
23056 (char *)"swigvarlink", /* Type name (tp_name) */
23057 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23058 0, /* Itemsize (tp_itemsize) */
23059 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23060 (printfunc) swig_varlink_print, /* Print (tp_print) */
23061 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23062 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23063 0, /* tp_compare */
23064 (reprfunc) swig_varlink_repr, /* tp_repr */
23065 0, /* tp_as_number */
23066 0, /* tp_as_sequence */
23067 0, /* tp_as_mapping */
23068 0, /* tp_hash */
23069 0, /* tp_call */
23070 (reprfunc)swig_varlink_str, /* tp_str */
23071 0, /* tp_getattro */
23072 0, /* tp_setattro */
23073 0, /* tp_as_buffer */
23074 0, /* tp_flags */
23075 varlink__doc__, /* tp_doc */
23076 0, /* tp_traverse */
23077 0, /* tp_clear */
23078 0, /* tp_richcompare */
23079 0, /* tp_weaklistoffset */
23080 #if PY_VERSION_HEX >= 0x02020000
23081 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23082 #endif
23083 #if PY_VERSION_HEX >= 0x02030000
23084 0, /* tp_del */
23085 #endif
23086 #ifdef COUNT_ALLOCS
23087 0,0,0,0 /* tp_alloc -> tp_next */
23088 #endif
23089 };
23090 varlink_type = tmp;
23091 varlink_type.ob_type = &PyType_Type;
23092 type_init = 1;
23093 }
23094 return &varlink_type;
23095 }
23096
23097 /* Create a variable linking object for use later */
23098 SWIGINTERN PyObject *
23099 SWIG_Python_newvarlink(void) {
23100 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23101 if (result) {
23102 result->vars = 0;
23103 }
23104 return ((PyObject*) result);
23105 }
23106
23107 SWIGINTERN void
23108 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23109 swig_varlinkobject *v = (swig_varlinkobject *) p;
23110 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23111 if (gv) {
23112 size_t size = strlen(name)+1;
23113 gv->name = (char *)malloc(size);
23114 if (gv->name) {
23115 strncpy(gv->name,name,size);
23116 gv->get_attr = get_attr;
23117 gv->set_attr = set_attr;
23118 gv->next = v->vars;
23119 }
23120 }
23121 v->vars = gv;
23122 }
23123
23124 SWIGINTERN PyObject *
23125 SWIG_globals() {
23126 static PyObject *_SWIG_globals = 0;
23127 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23128 return _SWIG_globals;
23129 }
23130
23131 /* -----------------------------------------------------------------------------
23132 * constants/methods manipulation
23133 * ----------------------------------------------------------------------------- */
23134
23135 /* Install Constants */
23136 SWIGINTERN void
23137 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23138 PyObject *obj = 0;
23139 size_t i;
23140 for (i = 0; constants[i].type; ++i) {
23141 switch(constants[i].type) {
23142 case SWIG_PY_POINTER:
23143 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23144 break;
23145 case SWIG_PY_BINARY:
23146 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23147 break;
23148 default:
23149 obj = 0;
23150 break;
23151 }
23152 if (obj) {
23153 PyDict_SetItemString(d, constants[i].name, obj);
23154 Py_DECREF(obj);
23155 }
23156 }
23157 }
23158
23159 /* -----------------------------------------------------------------------------*/
23160 /* Fix SwigMethods to carry the callback ptrs when needed */
23161 /* -----------------------------------------------------------------------------*/
23162
23163 SWIGINTERN void
23164 SWIG_Python_FixMethods(PyMethodDef *methods,
23165 swig_const_info *const_table,
23166 swig_type_info **types,
23167 swig_type_info **types_initial) {
23168 size_t i;
23169 for (i = 0; methods[i].ml_name; ++i) {
23170 const char *c = methods[i].ml_doc;
23171 if (c && (c = strstr(c, "swig_ptr: "))) {
23172 int j;
23173 swig_const_info *ci = 0;
23174 const char *name = c + 10;
23175 for (j = 0; const_table[j].type; ++j) {
23176 if (strncmp(const_table[j].name, name,
23177 strlen(const_table[j].name)) == 0) {
23178 ci = &(const_table[j]);
23179 break;
23180 }
23181 }
23182 if (ci) {
23183 size_t shift = (ci->ptype) - types;
23184 swig_type_info *ty = types_initial[shift];
23185 size_t ldoc = (c - methods[i].ml_doc);
23186 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23187 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23188 if (ndoc) {
23189 char *buff = ndoc;
23190 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23191 if (ptr) {
23192 strncpy(buff, methods[i].ml_doc, ldoc);
23193 buff += ldoc;
23194 strncpy(buff, "swig_ptr: ", 10);
23195 buff += 10;
23196 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23197 methods[i].ml_doc = ndoc;
23198 }
23199 }
23200 }
23201 }
23202 }
23203 }
23204
23205 #ifdef __cplusplus
23206 }
23207 #endif
23208
23209 /* -----------------------------------------------------------------------------*
23210 * Partial Init method
23211 * -----------------------------------------------------------------------------*/
23212
23213 #ifdef __cplusplus
23214 extern "C"
23215 #endif
23216 SWIGEXPORT void SWIG_init(void) {
23217 PyObject *m, *d;
23218
23219 /* Fix SwigMethods to carry the callback ptrs when needed */
23220 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23221
23222 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23223 d = PyModule_GetDict(m);
23224
23225 SWIG_InitializeModule(0);
23226 SWIG_InstallConstants(d,swig_const_table);
23227
23228
23229 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23230 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23231 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23232 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23233 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23234 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23235 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23236 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23237 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23238 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23239 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23240 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23241 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23242 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23243 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23244 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23245 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23246 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23247 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23248 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23249 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23250 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23251 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23252 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23253 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23254 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23255 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23256 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23257 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23258 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23259 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23260 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23261 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23262 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23263 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23264 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23265 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23266 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23267 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23268 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23269 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23270 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23271 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23272 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23273 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23274 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23275 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23276 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23277 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23278 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23279 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23280 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23281 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23282 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23283 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23284 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23285
23286
23287 }
23288
wxWidgets (Impactor)