]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add missing "public" so wxGridCellRenderer methods will have wrappers
[wxWidgets.git] / wxPython / src / msw / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMoveEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[104]
2571 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNcPaintEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNotifyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxPCXHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNGHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNMHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialog swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPanel swig_types[117]
2584 #define SWIGTYPE_p_wxPaperSize swig_types[118]
2585 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[119]
2586 #define SWIGTYPE_p_wxPen swig_types[120]
2587 #define SWIGTYPE_p_wxPoint swig_types[121]
2588 #define SWIGTYPE_p_wxPopupWindow swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewCanvas swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewControlBar swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewFrame swig_types[125]
2592 #define SWIGTYPE_p_wxPrintData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialog swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialogData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintPreview swig_types[129]
2596 #define SWIGTYPE_p_wxPrinter swig_types[130]
2597 #define SWIGTYPE_p_wxProgressDialog swig_types[131]
2598 #define SWIGTYPE_p_wxPyApp swig_types[132]
2599 #define SWIGTYPE_p_wxPyCommandEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridTableBase swig_types[138]
2605 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[139]
2606 #define SWIGTYPE_p_wxPyImageHandler swig_types[140]
2607 #define SWIGTYPE_p_wxPyPanel swig_types[141]
2608 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintPreview swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintout swig_types[146]
2613 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[147]
2614 #define SWIGTYPE_p_wxPySizer swig_types[148]
2615 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[149]
2616 #define SWIGTYPE_p_wxPyVListBox swig_types[150]
2617 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPyValidator swig_types[152]
2619 #define SWIGTYPE_p_wxPyWindow swig_types[153]
2620 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[154]
2621 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[155]
2622 #define SWIGTYPE_p_wxRect swig_types[156]
2623 #define SWIGTYPE_p_wxSashEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[158]
2625 #define SWIGTYPE_p_wxSashWindow swig_types[159]
2626 #define SWIGTYPE_p_wxScrollEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrollWinEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrolledWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSetCursorEvent swig_types[163]
2630 #define SWIGTYPE_p_wxShowEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[165]
2632 #define SWIGTYPE_p_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 wxPyGridNameStr(wxGridNameStr);
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 *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5508 PyObject *obj;
5509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5510 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5511 return SWIG_Py_Void();
5512 }
5513
5514 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5515 return SWIG_Python_InitShadowInstance(args);
5516 }
5517
5518 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 int arg1 = (int) 0 ;
5521 wxString *arg2 = (wxString *) NULL ;
5522 bool arg3 = (bool) false ;
5523 wxGridCellChoiceEditor *result = 0 ;
5524 bool val3 ;
5525 int ecode3 = 0 ;
5526 PyObject * obj0 = 0 ;
5527 PyObject * obj1 = 0 ;
5528 char * kwnames[] = {
5529 (char *) "choices",(char *) "allowOthers", NULL
5530 };
5531
5532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5533 if (obj0) {
5534 {
5535 arg1 = PyList_Size(obj0);
5536 arg2 = wxString_LIST_helper(obj0);
5537 if (arg2 == NULL) SWIG_fail;
5538 }
5539 }
5540 if (obj1) {
5541 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5542 if (!SWIG_IsOK(ecode3)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5544 }
5545 arg3 = static_cast< bool >(val3);
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5554 {
5555 if (arg2) delete [] arg2;
5556 }
5557 return resultobj;
5558 fail:
5559 {
5560 if (arg2) delete [] arg2;
5561 }
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *obj;
5568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5569 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5570 return SWIG_Py_Void();
5571 }
5572
5573 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5574 return SWIG_Python_InitShadowInstance(args);
5575 }
5576
5577 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj = 0;
5579 wxString const &arg1_defvalue = wxPyEmptyString ;
5580 wxString *arg1 = (wxString *) &arg1_defvalue ;
5581 wxGridCellEnumEditor *result = 0 ;
5582 bool temp1 = false ;
5583 PyObject * obj0 = 0 ;
5584 char * kwnames[] = {
5585 (char *) "choices", NULL
5586 };
5587
5588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5589 if (obj0) {
5590 {
5591 arg1 = wxString_in_helper(obj0);
5592 if (arg1 == NULL) SWIG_fail;
5593 temp1 = true;
5594 }
5595 }
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5603 {
5604 if (temp1)
5605 delete arg1;
5606 }
5607 return resultobj;
5608 fail:
5609 {
5610 if (temp1)
5611 delete arg1;
5612 }
5613 return NULL;
5614 }
5615
5616
5617 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5618 PyObject *obj;
5619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5620 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5621 return SWIG_Py_Void();
5622 }
5623
5624 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5625 return SWIG_Python_InitShadowInstance(args);
5626 }
5627
5628 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5629 PyObject *resultobj = 0;
5630 wxGridCellAutoWrapStringEditor *result = 0 ;
5631
5632 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5633 {
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5647 PyObject *obj;
5648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5649 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5650 return SWIG_Py_Void();
5651 }
5652
5653 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5654 return SWIG_Python_InitShadowInstance(args);
5655 }
5656
5657 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5660 PyObject *arg2 = (PyObject *) 0 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 char * kwnames[] = {
5666 (char *) "self",(char *) "_self", NULL
5667 };
5668
5669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5671 if (!SWIG_IsOK(res1)) {
5672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5673 }
5674 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5675 arg2 = obj1;
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 wxGridCellAttr__setOORInfo(arg1,arg2);
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 resultobj = SWIG_Py_Void();
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5690 PyObject *resultobj = 0;
5691 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5692 wxGridCellAttr *result = 0 ;
5693 void *argp1 = 0 ;
5694 int res1 = 0 ;
5695 PyObject * obj0 = 0 ;
5696 char * kwnames[] = {
5697 (char *) "attrDefault", NULL
5698 };
5699
5700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5701 if (obj0) {
5702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5703 if (!SWIG_IsOK(res1)) {
5704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5705 }
5706 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5707 }
5708 {
5709 PyThreadState* __tstate = wxPyBeginAllowThreads();
5710 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5711 wxPyEndAllowThreads(__tstate);
5712 if (PyErr_Occurred()) SWIG_fail;
5713 }
5714 {
5715 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5716 }
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
5723 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5724 PyObject *resultobj = 0;
5725 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5726 void *argp1 = 0 ;
5727 int res1 = 0 ;
5728 PyObject *swig_obj[1] ;
5729
5730 if (!args) SWIG_fail;
5731 swig_obj[0] = args;
5732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5733 if (!SWIG_IsOK(res1)) {
5734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5735 }
5736 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 delete_wxGridCellAttr(arg1);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 resultobj = SWIG_Py_Void();
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5752 PyObject *resultobj = 0;
5753 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5754 wxGridCellAttr *result = 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 PyObject *swig_obj[1] ;
5758
5759 if (!args) SWIG_fail;
5760 swig_obj[0] = args;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5764 }
5765 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 {
5773 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5774 }
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5784 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 void *argp2 = 0 ;
5788 int res2 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char * kwnames[] = {
5792 (char *) "self",(char *) "mergefrom", NULL
5793 };
5794
5795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5797 if (!SWIG_IsOK(res1)) {
5798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5799 }
5800 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5802 if (!SWIG_IsOK(res2)) {
5803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5804 }
5805 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5806 {
5807 PyThreadState* __tstate = wxPyBeginAllowThreads();
5808 (arg1)->MergeWith(arg2);
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_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5820 PyObject *resultobj = 0;
5821 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5822 void *argp1 = 0 ;
5823 int res1 = 0 ;
5824 PyObject *swig_obj[1] ;
5825
5826 if (!args) SWIG_fail;
5827 swig_obj[0] = args;
5828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5831 }
5832 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 (arg1)->IncRef();
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 resultobj = SWIG_Py_Void();
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5847 PyObject *resultobj = 0;
5848 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5849 void *argp1 = 0 ;
5850 int res1 = 0 ;
5851 PyObject *swig_obj[1] ;
5852
5853 if (!args) SWIG_fail;
5854 swig_obj[0] = args;
5855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5856 if (!SWIG_IsOK(res1)) {
5857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5858 }
5859 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5860 {
5861 PyThreadState* __tstate = wxPyBeginAllowThreads();
5862 (arg1)->DecRef();
5863 wxPyEndAllowThreads(__tstate);
5864 if (PyErr_Occurred()) SWIG_fail;
5865 }
5866 resultobj = SWIG_Py_Void();
5867 return resultobj;
5868 fail:
5869 return NULL;
5870 }
5871
5872
5873 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj = 0;
5875 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5876 wxColour *arg2 = 0 ;
5877 void *argp1 = 0 ;
5878 int res1 = 0 ;
5879 wxColour temp2 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 char * kwnames[] = {
5883 (char *) "self",(char *) "colText", NULL
5884 };
5885
5886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5888 if (!SWIG_IsOK(res1)) {
5889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5890 }
5891 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5892 {
5893 arg2 = &temp2;
5894 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5895 }
5896 {
5897 PyThreadState* __tstate = wxPyBeginAllowThreads();
5898 (arg1)->SetTextColour((wxColour const &)*arg2);
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 resultobj = SWIG_Py_Void();
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = 0;
5911 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5912 wxColour *arg2 = 0 ;
5913 void *argp1 = 0 ;
5914 int res1 = 0 ;
5915 wxColour temp2 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 char * kwnames[] = {
5919 (char *) "self",(char *) "colBack", NULL
5920 };
5921
5922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5924 if (!SWIG_IsOK(res1)) {
5925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5926 }
5927 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5928 {
5929 arg2 = &temp2;
5930 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5931 }
5932 {
5933 PyThreadState* __tstate = wxPyBeginAllowThreads();
5934 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_Py_Void();
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5948 wxFont *arg2 = 0 ;
5949 void *argp1 = 0 ;
5950 int res1 = 0 ;
5951 void *argp2 = 0 ;
5952 int res2 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "font", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5963 }
5964 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
5966 if (!SWIG_IsOK(res2)) {
5967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
5968 }
5969 if (!argp2) {
5970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
5971 }
5972 arg2 = reinterpret_cast< wxFont * >(argp2);
5973 {
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 (arg1)->SetFont((wxFont const &)*arg2);
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 resultobj = SWIG_Py_Void();
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = 0;
5988 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5989 int arg2 ;
5990 int arg3 ;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 int val2 ;
5994 int ecode2 = 0 ;
5995 int val3 ;
5996 int ecode3 = 0 ;
5997 PyObject * obj0 = 0 ;
5998 PyObject * obj1 = 0 ;
5999 PyObject * obj2 = 0 ;
6000 char * kwnames[] = {
6001 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6002 };
6003
6004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6006 if (!SWIG_IsOK(res1)) {
6007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6008 }
6009 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6010 ecode2 = SWIG_AsVal_int(obj1, &val2);
6011 if (!SWIG_IsOK(ecode2)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6013 }
6014 arg2 = static_cast< int >(val2);
6015 ecode3 = SWIG_AsVal_int(obj2, &val3);
6016 if (!SWIG_IsOK(ecode3)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6018 }
6019 arg3 = static_cast< int >(val3);
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 (arg1)->SetAlignment(arg2,arg3);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_Py_Void();
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj = 0;
6035 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6036 int arg2 ;
6037 int arg3 ;
6038 void *argp1 = 0 ;
6039 int res1 = 0 ;
6040 int val2 ;
6041 int ecode2 = 0 ;
6042 int val3 ;
6043 int ecode3 = 0 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 PyObject * obj2 = 0 ;
6047 char * kwnames[] = {
6048 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6049 };
6050
6051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6053 if (!SWIG_IsOK(res1)) {
6054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6055 }
6056 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6057 ecode2 = SWIG_AsVal_int(obj1, &val2);
6058 if (!SWIG_IsOK(ecode2)) {
6059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6060 }
6061 arg2 = static_cast< int >(val2);
6062 ecode3 = SWIG_AsVal_int(obj2, &val3);
6063 if (!SWIG_IsOK(ecode3)) {
6064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6065 }
6066 arg3 = static_cast< int >(val3);
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 (arg1)->SetSize(arg2,arg3);
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 resultobj = SWIG_Py_Void();
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj = 0;
6082 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6083 bool arg2 = (bool) true ;
6084 void *argp1 = 0 ;
6085 int res1 = 0 ;
6086 bool val2 ;
6087 int ecode2 = 0 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "self",(char *) "allow", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6096 if (!SWIG_IsOK(res1)) {
6097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6098 }
6099 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6100 if (obj1) {
6101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6102 if (!SWIG_IsOK(ecode2)) {
6103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6104 }
6105 arg2 = static_cast< bool >(val2);
6106 }
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 (arg1)->SetOverflow(arg2);
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_Py_Void();
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6123 bool arg2 = (bool) true ;
6124 void *argp1 = 0 ;
6125 int res1 = 0 ;
6126 bool val2 ;
6127 int ecode2 = 0 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char * kwnames[] = {
6131 (char *) "self",(char *) "isReadOnly", NULL
6132 };
6133
6134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6138 }
6139 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6140 if (obj1) {
6141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6142 if (!SWIG_IsOK(ecode2)) {
6143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6144 }
6145 arg2 = static_cast< bool >(val2);
6146 }
6147 {
6148 PyThreadState* __tstate = wxPyBeginAllowThreads();
6149 (arg1)->SetReadOnly(arg2);
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 resultobj = SWIG_Py_Void();
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj = 0;
6162 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6163 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6164 void *argp1 = 0 ;
6165 int res1 = 0 ;
6166 void *argp2 = 0 ;
6167 int res2 = 0 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char * kwnames[] = {
6171 (char *) "self",(char *) "renderer", NULL
6172 };
6173
6174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6176 if (!SWIG_IsOK(res1)) {
6177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6178 }
6179 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6181 if (!SWIG_IsOK(res2)) {
6182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6183 }
6184 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6185 {
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 (arg1)->SetRenderer(arg2);
6188 wxPyEndAllowThreads(__tstate);
6189 if (PyErr_Occurred()) SWIG_fail;
6190 }
6191 resultobj = SWIG_Py_Void();
6192 return resultobj;
6193 fail:
6194 return NULL;
6195 }
6196
6197
6198 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6199 PyObject *resultobj = 0;
6200 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6201 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6202 void *argp1 = 0 ;
6203 int res1 = 0 ;
6204 void *argp2 = 0 ;
6205 int res2 = 0 ;
6206 PyObject * obj0 = 0 ;
6207 PyObject * obj1 = 0 ;
6208 char * kwnames[] = {
6209 (char *) "self",(char *) "editor", NULL
6210 };
6211
6212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6214 if (!SWIG_IsOK(res1)) {
6215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6216 }
6217 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6219 if (!SWIG_IsOK(res2)) {
6220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6221 }
6222 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6223 {
6224 PyThreadState* __tstate = wxPyBeginAllowThreads();
6225 (arg1)->SetEditor(arg2);
6226 wxPyEndAllowThreads(__tstate);
6227 if (PyErr_Occurred()) SWIG_fail;
6228 }
6229 resultobj = SWIG_Py_Void();
6230 return resultobj;
6231 fail:
6232 return NULL;
6233 }
6234
6235
6236 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj = 0;
6238 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6239 wxGridCellAttr::wxAttrKind arg2 ;
6240 void *argp1 = 0 ;
6241 int res1 = 0 ;
6242 int val2 ;
6243 int ecode2 = 0 ;
6244 PyObject * obj0 = 0 ;
6245 PyObject * obj1 = 0 ;
6246 char * kwnames[] = {
6247 (char *) "self",(char *) "kind", NULL
6248 };
6249
6250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6252 if (!SWIG_IsOK(res1)) {
6253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6254 }
6255 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6256 ecode2 = SWIG_AsVal_int(obj1, &val2);
6257 if (!SWIG_IsOK(ecode2)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6259 }
6260 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6261 {
6262 PyThreadState* __tstate = wxPyBeginAllowThreads();
6263 (arg1)->SetKind(arg2);
6264 wxPyEndAllowThreads(__tstate);
6265 if (PyErr_Occurred()) SWIG_fail;
6266 }
6267 resultobj = SWIG_Py_Void();
6268 return resultobj;
6269 fail:
6270 return NULL;
6271 }
6272
6273
6274 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6275 PyObject *resultobj = 0;
6276 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6277 bool result;
6278 void *argp1 = 0 ;
6279 int res1 = 0 ;
6280 PyObject *swig_obj[1] ;
6281
6282 if (!args) SWIG_fail;
6283 swig_obj[0] = args;
6284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6285 if (!SWIG_IsOK(res1)) {
6286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6287 }
6288 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 {
6296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6297 }
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6305 PyObject *resultobj = 0;
6306 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6307 bool result;
6308 void *argp1 = 0 ;
6309 int res1 = 0 ;
6310 PyObject *swig_obj[1] ;
6311
6312 if (!args) SWIG_fail;
6313 swig_obj[0] = args;
6314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6315 if (!SWIG_IsOK(res1)) {
6316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6317 }
6318 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6319 {
6320 PyThreadState* __tstate = wxPyBeginAllowThreads();
6321 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 {
6326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6327 }
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6335 PyObject *resultobj = 0;
6336 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6337 bool result;
6338 void *argp1 = 0 ;
6339 int res1 = 0 ;
6340 PyObject *swig_obj[1] ;
6341
6342 if (!args) SWIG_fail;
6343 swig_obj[0] = args;
6344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6345 if (!SWIG_IsOK(res1)) {
6346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6347 }
6348 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6357 }
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6365 PyObject *resultobj = 0;
6366 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6367 bool result;
6368 void *argp1 = 0 ;
6369 int res1 = 0 ;
6370 PyObject *swig_obj[1] ;
6371
6372 if (!args) SWIG_fail;
6373 swig_obj[0] = args;
6374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6375 if (!SWIG_IsOK(res1)) {
6376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6377 }
6378 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6379 {
6380 PyThreadState* __tstate = wxPyBeginAllowThreads();
6381 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 {
6386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6387 }
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6397 bool result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 {
6416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6417 }
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425 PyObject *resultobj = 0;
6426 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6427 bool result;
6428 void *argp1 = 0 ;
6429 int res1 = 0 ;
6430 PyObject *swig_obj[1] ;
6431
6432 if (!args) SWIG_fail;
6433 swig_obj[0] = args;
6434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6437 }
6438 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 {
6446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6447 }
6448 return resultobj;
6449 fail:
6450 return NULL;
6451 }
6452
6453
6454 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6455 PyObject *resultobj = 0;
6456 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6457 bool result;
6458 void *argp1 = 0 ;
6459 int res1 = 0 ;
6460 PyObject *swig_obj[1] ;
6461
6462 if (!args) SWIG_fail;
6463 swig_obj[0] = args;
6464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6465 if (!SWIG_IsOK(res1)) {
6466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6467 }
6468 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6472 wxPyEndAllowThreads(__tstate);
6473 if (PyErr_Occurred()) SWIG_fail;
6474 }
6475 {
6476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6477 }
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 PyObject *resultobj = 0;
6486 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6487 bool result;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 PyObject *swig_obj[1] ;
6491
6492 if (!args) SWIG_fail;
6493 swig_obj[0] = args;
6494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6495 if (!SWIG_IsOK(res1)) {
6496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6497 }
6498 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6499 {
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 {
6506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6515 PyObject *resultobj = 0;
6516 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6517 wxColour result;
6518 void *argp1 = 0 ;
6519 int res1 = 0 ;
6520 PyObject *swig_obj[1] ;
6521
6522 if (!args) SWIG_fail;
6523 swig_obj[0] = args;
6524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6525 if (!SWIG_IsOK(res1)) {
6526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6527 }
6528 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6545 wxColour result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6573 wxFont result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 result = ((wxGridCellAttr const *)arg1)->GetFont();
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6599 PyObject *resultobj = 0;
6600 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6601 int *arg2 = (int *) 0 ;
6602 int *arg3 = (int *) 0 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int temp2 ;
6606 int res2 = SWIG_TMPOBJ ;
6607 int temp3 ;
6608 int res3 = SWIG_TMPOBJ ;
6609 PyObject *swig_obj[1] ;
6610
6611 arg2 = &temp2;
6612 arg3 = &temp3;
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_Py_Void();
6627 if (SWIG_IsTmpObj(res2)) {
6628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6629 } else {
6630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6632 }
6633 if (SWIG_IsTmpObj(res3)) {
6634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6635 } else {
6636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6638 }
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6646 PyObject *resultobj = 0;
6647 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6648 int *arg2 = (int *) 0 ;
6649 int *arg3 = (int *) 0 ;
6650 void *argp1 = 0 ;
6651 int res1 = 0 ;
6652 int temp2 ;
6653 int res2 = SWIG_TMPOBJ ;
6654 int temp3 ;
6655 int res3 = SWIG_TMPOBJ ;
6656 PyObject *swig_obj[1] ;
6657
6658 arg2 = &temp2;
6659 arg3 = &temp3;
6660 if (!args) SWIG_fail;
6661 swig_obj[0] = args;
6662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6663 if (!SWIG_IsOK(res1)) {
6664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6665 }
6666 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6667 {
6668 PyThreadState* __tstate = wxPyBeginAllowThreads();
6669 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 resultobj = SWIG_Py_Void();
6674 if (SWIG_IsTmpObj(res2)) {
6675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6676 } else {
6677 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6679 }
6680 if (SWIG_IsTmpObj(res3)) {
6681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6682 } else {
6683 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6685 }
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6693 PyObject *resultobj = 0;
6694 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6695 bool result;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 PyObject *swig_obj[1] ;
6699
6700 if (!args) SWIG_fail;
6701 swig_obj[0] = args;
6702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6703 if (!SWIG_IsOK(res1)) {
6704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6705 }
6706 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 {
6714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6715 }
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = 0;
6724 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6725 wxGrid *arg2 = (wxGrid *) 0 ;
6726 int arg3 ;
6727 int arg4 ;
6728 wxGridCellRenderer *result = 0 ;
6729 void *argp1 = 0 ;
6730 int res1 = 0 ;
6731 void *argp2 = 0 ;
6732 int res2 = 0 ;
6733 int val3 ;
6734 int ecode3 = 0 ;
6735 int val4 ;
6736 int ecode4 = 0 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 PyObject * obj2 = 0 ;
6740 PyObject * obj3 = 0 ;
6741 char * kwnames[] = {
6742 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6743 };
6744
6745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6747 if (!SWIG_IsOK(res1)) {
6748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6749 }
6750 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6752 if (!SWIG_IsOK(res2)) {
6753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6754 }
6755 arg2 = reinterpret_cast< wxGrid * >(argp2);
6756 ecode3 = SWIG_AsVal_int(obj2, &val3);
6757 if (!SWIG_IsOK(ecode3)) {
6758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6759 }
6760 arg3 = static_cast< int >(val3);
6761 ecode4 = SWIG_AsVal_int(obj3, &val4);
6762 if (!SWIG_IsOK(ecode4)) {
6763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6764 }
6765 arg4 = static_cast< int >(val4);
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 {
6773 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6774 }
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj = 0;
6783 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6784 wxGrid *arg2 = (wxGrid *) 0 ;
6785 int arg3 ;
6786 int arg4 ;
6787 wxGridCellEditor *result = 0 ;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 void *argp2 = 0 ;
6791 int res2 = 0 ;
6792 int val3 ;
6793 int ecode3 = 0 ;
6794 int val4 ;
6795 int ecode4 = 0 ;
6796 PyObject * obj0 = 0 ;
6797 PyObject * obj1 = 0 ;
6798 PyObject * obj2 = 0 ;
6799 PyObject * obj3 = 0 ;
6800 char * kwnames[] = {
6801 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6802 };
6803
6804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6808 }
6809 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6811 if (!SWIG_IsOK(res2)) {
6812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6813 }
6814 arg2 = reinterpret_cast< wxGrid * >(argp2);
6815 ecode3 = SWIG_AsVal_int(obj2, &val3);
6816 if (!SWIG_IsOK(ecode3)) {
6817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6818 }
6819 arg3 = static_cast< int >(val3);
6820 ecode4 = SWIG_AsVal_int(obj3, &val4);
6821 if (!SWIG_IsOK(ecode4)) {
6822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6823 }
6824 arg4 = static_cast< int >(val4);
6825 {
6826 PyThreadState* __tstate = wxPyBeginAllowThreads();
6827 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 {
6832 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6833 }
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6843 bool result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 {
6862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6863 }
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6871 PyObject *resultobj = 0;
6872 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6873 wxGridCellAttr::wxAttrKind result;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 PyObject *swig_obj[1] ;
6877
6878 if (!args) SWIG_fail;
6879 swig_obj[0] = args;
6880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6881 if (!SWIG_IsOK(res1)) {
6882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6883 }
6884 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6885 {
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 resultobj = SWIG_From_int(static_cast< int >(result));
6892 return resultobj;
6893 fail:
6894 return NULL;
6895 }
6896
6897
6898 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6899 PyObject *resultobj = 0;
6900 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6901 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6902 void *argp1 = 0 ;
6903 int res1 = 0 ;
6904 void *argp2 = 0 ;
6905 int res2 = 0 ;
6906 PyObject * obj0 = 0 ;
6907 PyObject * obj1 = 0 ;
6908 char * kwnames[] = {
6909 (char *) "self",(char *) "defAttr", NULL
6910 };
6911
6912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6914 if (!SWIG_IsOK(res1)) {
6915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6916 }
6917 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6918 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6919 if (!SWIG_IsOK(res2)) {
6920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6921 }
6922 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 (arg1)->SetDefAttr(arg2);
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_Py_Void();
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937 PyObject *obj;
6938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6939 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
6940 return SWIG_Py_Void();
6941 }
6942
6943 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 return SWIG_Python_InitShadowInstance(args);
6945 }
6946
6947 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6948 PyObject *resultobj = 0;
6949 wxGridCellAttrProvider *result = 0 ;
6950
6951 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
6952 {
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 {
6959 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
6960 }
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj = 0;
6969 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
6970 PyObject *arg2 = (PyObject *) 0 ;
6971 void *argp1 = 0 ;
6972 int res1 = 0 ;
6973 PyObject * obj0 = 0 ;
6974 PyObject * obj1 = 0 ;
6975 char * kwnames[] = {
6976 (char *) "self",(char *) "_self", NULL
6977 };
6978
6979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
6981 if (!SWIG_IsOK(res1)) {
6982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
6983 }
6984 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
6985 arg2 = obj1;
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
6989 wxPyEndAllowThreads(__tstate);
6990 if (PyErr_Occurred()) SWIG_fail;
6991 }
6992 resultobj = SWIG_Py_Void();
6993 return resultobj;
6994 fail:
6995 return NULL;
6996 }
6997
6998
6999 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7000 PyObject *resultobj = 0;
7001 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7002 int arg2 ;
7003 int arg3 ;
7004 wxGridCellAttr::wxAttrKind arg4 ;
7005 wxGridCellAttr *result = 0 ;
7006 void *argp1 = 0 ;
7007 int res1 = 0 ;
7008 int val2 ;
7009 int ecode2 = 0 ;
7010 int val3 ;
7011 int ecode3 = 0 ;
7012 int val4 ;
7013 int ecode4 = 0 ;
7014 PyObject * obj0 = 0 ;
7015 PyObject * obj1 = 0 ;
7016 PyObject * obj2 = 0 ;
7017 PyObject * obj3 = 0 ;
7018 char * kwnames[] = {
7019 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7020 };
7021
7022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7024 if (!SWIG_IsOK(res1)) {
7025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7026 }
7027 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7028 ecode2 = SWIG_AsVal_int(obj1, &val2);
7029 if (!SWIG_IsOK(ecode2)) {
7030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7031 }
7032 arg2 = static_cast< int >(val2);
7033 ecode3 = SWIG_AsVal_int(obj2, &val3);
7034 if (!SWIG_IsOK(ecode3)) {
7035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7036 }
7037 arg3 = static_cast< int >(val3);
7038 ecode4 = SWIG_AsVal_int(obj3, &val4);
7039 if (!SWIG_IsOK(ecode4)) {
7040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7041 }
7042 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 {
7050 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7051 }
7052 return resultobj;
7053 fail:
7054 return NULL;
7055 }
7056
7057
7058 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7059 PyObject *resultobj = 0;
7060 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7061 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7062 int arg3 ;
7063 int arg4 ;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 void *argp2 = 0 ;
7067 int res2 = 0 ;
7068 int val3 ;
7069 int ecode3 = 0 ;
7070 int val4 ;
7071 int ecode4 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 PyObject * obj1 = 0 ;
7074 PyObject * obj2 = 0 ;
7075 PyObject * obj3 = 0 ;
7076 char * kwnames[] = {
7077 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7078 };
7079
7080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7082 if (!SWIG_IsOK(res1)) {
7083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7084 }
7085 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7087 if (!SWIG_IsOK(res2)) {
7088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7089 }
7090 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7091 ecode3 = SWIG_AsVal_int(obj2, &val3);
7092 if (!SWIG_IsOK(ecode3)) {
7093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7094 }
7095 arg3 = static_cast< int >(val3);
7096 ecode4 = SWIG_AsVal_int(obj3, &val4);
7097 if (!SWIG_IsOK(ecode4)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7099 }
7100 arg4 = static_cast< int >(val4);
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 (arg1)->SetAttr(arg2,arg3,arg4);
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 resultobj = SWIG_Py_Void();
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7115 PyObject *resultobj = 0;
7116 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7117 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7118 int arg3 ;
7119 void *argp1 = 0 ;
7120 int res1 = 0 ;
7121 void *argp2 = 0 ;
7122 int res2 = 0 ;
7123 int val3 ;
7124 int ecode3 = 0 ;
7125 PyObject * obj0 = 0 ;
7126 PyObject * obj1 = 0 ;
7127 PyObject * obj2 = 0 ;
7128 char * kwnames[] = {
7129 (char *) "self",(char *) "attr",(char *) "row", NULL
7130 };
7131
7132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7134 if (!SWIG_IsOK(res1)) {
7135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7136 }
7137 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7139 if (!SWIG_IsOK(res2)) {
7140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7141 }
7142 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7143 ecode3 = SWIG_AsVal_int(obj2, &val3);
7144 if (!SWIG_IsOK(ecode3)) {
7145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7146 }
7147 arg3 = static_cast< int >(val3);
7148 {
7149 PyThreadState* __tstate = wxPyBeginAllowThreads();
7150 (arg1)->SetRowAttr(arg2,arg3);
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 resultobj = SWIG_Py_Void();
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj = 0;
7163 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7164 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7165 int arg3 ;
7166 void *argp1 = 0 ;
7167 int res1 = 0 ;
7168 void *argp2 = 0 ;
7169 int res2 = 0 ;
7170 int val3 ;
7171 int ecode3 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 PyObject * obj2 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "self",(char *) "attr",(char *) "col", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7181 if (!SWIG_IsOK(res1)) {
7182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7183 }
7184 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7186 if (!SWIG_IsOK(res2)) {
7187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7188 }
7189 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7190 ecode3 = SWIG_AsVal_int(obj2, &val3);
7191 if (!SWIG_IsOK(ecode3)) {
7192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7193 }
7194 arg3 = static_cast< int >(val3);
7195 {
7196 PyThreadState* __tstate = wxPyBeginAllowThreads();
7197 (arg1)->SetColAttr(arg2,arg3);
7198 wxPyEndAllowThreads(__tstate);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 resultobj = SWIG_Py_Void();
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj = 0;
7210 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7211 size_t arg2 ;
7212 int arg3 ;
7213 void *argp1 = 0 ;
7214 int res1 = 0 ;
7215 size_t val2 ;
7216 int ecode2 = 0 ;
7217 int val3 ;
7218 int ecode3 = 0 ;
7219 PyObject * obj0 = 0 ;
7220 PyObject * obj1 = 0 ;
7221 PyObject * obj2 = 0 ;
7222 char * kwnames[] = {
7223 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7224 };
7225
7226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7228 if (!SWIG_IsOK(res1)) {
7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7230 }
7231 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7232 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7233 if (!SWIG_IsOK(ecode2)) {
7234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7235 }
7236 arg2 = static_cast< size_t >(val2);
7237 ecode3 = SWIG_AsVal_int(obj2, &val3);
7238 if (!SWIG_IsOK(ecode3)) {
7239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7240 }
7241 arg3 = static_cast< int >(val3);
7242 {
7243 PyThreadState* __tstate = wxPyBeginAllowThreads();
7244 (arg1)->UpdateAttrRows(arg2,arg3);
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 resultobj = SWIG_Py_Void();
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = 0;
7257 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7258 size_t arg2 ;
7259 int arg3 ;
7260 void *argp1 = 0 ;
7261 int res1 = 0 ;
7262 size_t val2 ;
7263 int ecode2 = 0 ;
7264 int val3 ;
7265 int ecode3 = 0 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 PyObject * obj2 = 0 ;
7269 char * kwnames[] = {
7270 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7271 };
7272
7273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7275 if (!SWIG_IsOK(res1)) {
7276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7277 }
7278 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7279 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7280 if (!SWIG_IsOK(ecode2)) {
7281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7282 }
7283 arg2 = static_cast< size_t >(val2);
7284 ecode3 = SWIG_AsVal_int(obj2, &val3);
7285 if (!SWIG_IsOK(ecode3)) {
7286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7287 }
7288 arg3 = static_cast< int >(val3);
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 (arg1)->UpdateAttrCols(arg2,arg3);
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 resultobj = SWIG_Py_Void();
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7303 PyObject *obj;
7304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7305 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7306 return SWIG_Py_Void();
7307 }
7308
7309 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7310 return SWIG_Python_InitShadowInstance(args);
7311 }
7312
7313 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7314 PyObject *resultobj = 0;
7315 wxPyGridCellAttrProvider *result = 0 ;
7316
7317 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj = 0;
7333 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7334 PyObject *arg2 = (PyObject *) 0 ;
7335 PyObject *arg3 = (PyObject *) 0 ;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 PyObject * obj0 = 0 ;
7339 PyObject * obj1 = 0 ;
7340 PyObject * obj2 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "self",(char *) "_class", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7349 }
7350 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7351 arg2 = obj1;
7352 arg3 = obj2;
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 (arg1)->_setCallbackInfo(arg2,arg3);
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_Py_Void();
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj = 0;
7368 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7369 int arg2 ;
7370 int arg3 ;
7371 wxGridCellAttr::wxAttrKind arg4 ;
7372 wxGridCellAttr *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 int val2 ;
7376 int ecode2 = 0 ;
7377 int val3 ;
7378 int ecode3 = 0 ;
7379 int val4 ;
7380 int ecode4 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 PyObject * obj3 = 0 ;
7385 char * kwnames[] = {
7386 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7387 };
7388
7389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7391 if (!SWIG_IsOK(res1)) {
7392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7393 }
7394 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7395 ecode2 = SWIG_AsVal_int(obj1, &val2);
7396 if (!SWIG_IsOK(ecode2)) {
7397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7398 }
7399 arg2 = static_cast< int >(val2);
7400 ecode3 = SWIG_AsVal_int(obj2, &val3);
7401 if (!SWIG_IsOK(ecode3)) {
7402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7403 }
7404 arg3 = static_cast< int >(val3);
7405 ecode4 = SWIG_AsVal_int(obj3, &val4);
7406 if (!SWIG_IsOK(ecode4)) {
7407 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7408 }
7409 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj = 0;
7427 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7428 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7429 int arg3 ;
7430 int arg4 ;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 void *argp2 = 0 ;
7434 int res2 = 0 ;
7435 int val3 ;
7436 int ecode3 = 0 ;
7437 int val4 ;
7438 int ecode4 = 0 ;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 PyObject * obj2 = 0 ;
7442 PyObject * obj3 = 0 ;
7443 char * kwnames[] = {
7444 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7445 };
7446
7447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7449 if (!SWIG_IsOK(res1)) {
7450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7451 }
7452 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7454 if (!SWIG_IsOK(res2)) {
7455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7456 }
7457 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7458 ecode3 = SWIG_AsVal_int(obj2, &val3);
7459 if (!SWIG_IsOK(ecode3)) {
7460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7461 }
7462 arg3 = static_cast< int >(val3);
7463 ecode4 = SWIG_AsVal_int(obj3, &val4);
7464 if (!SWIG_IsOK(ecode4)) {
7465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7466 }
7467 arg4 = static_cast< int >(val4);
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 (arg1)->SetAttr(arg2,arg3,arg4);
7471 wxPyEndAllowThreads(__tstate);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 resultobj = SWIG_Py_Void();
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj = 0;
7483 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7484 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7485 int arg3 ;
7486 void *argp1 = 0 ;
7487 int res1 = 0 ;
7488 void *argp2 = 0 ;
7489 int res2 = 0 ;
7490 int val3 ;
7491 int ecode3 = 0 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 PyObject * obj2 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "attr",(char *) "row", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7503 }
7504 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7506 if (!SWIG_IsOK(res2)) {
7507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7508 }
7509 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7510 ecode3 = SWIG_AsVal_int(obj2, &val3);
7511 if (!SWIG_IsOK(ecode3)) {
7512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7513 }
7514 arg3 = static_cast< int >(val3);
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 (arg1)->SetRowAttr(arg2,arg3);
7518 wxPyEndAllowThreads(__tstate);
7519 if (PyErr_Occurred()) SWIG_fail;
7520 }
7521 resultobj = SWIG_Py_Void();
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7531 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7532 int arg3 ;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 void *argp2 = 0 ;
7536 int res2 = 0 ;
7537 int val3 ;
7538 int ecode3 = 0 ;
7539 PyObject * obj0 = 0 ;
7540 PyObject * obj1 = 0 ;
7541 PyObject * obj2 = 0 ;
7542 char * kwnames[] = {
7543 (char *) "self",(char *) "attr",(char *) "col", NULL
7544 };
7545
7546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7548 if (!SWIG_IsOK(res1)) {
7549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7550 }
7551 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7553 if (!SWIG_IsOK(res2)) {
7554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7555 }
7556 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7557 ecode3 = SWIG_AsVal_int(obj2, &val3);
7558 if (!SWIG_IsOK(ecode3)) {
7559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7560 }
7561 arg3 = static_cast< int >(val3);
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 (arg1)->SetColAttr(arg2,arg3);
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = SWIG_Py_Void();
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7576 PyObject *obj;
7577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7578 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7579 return SWIG_Py_Void();
7580 }
7581
7582 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7583 return SWIG_Python_InitShadowInstance(args);
7584 }
7585
7586 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7587 PyObject *resultobj = 0;
7588 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 PyObject *swig_obj[1] ;
7592
7593 if (!args) SWIG_fail;
7594 swig_obj[0] = args;
7595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7596 if (!SWIG_IsOK(res1)) {
7597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7598 }
7599 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7600 {
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 delete arg1;
7603
7604 wxPyEndAllowThreads(__tstate);
7605 if (PyErr_Occurred()) SWIG_fail;
7606 }
7607 resultobj = SWIG_Py_Void();
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7615 PyObject *resultobj = 0;
7616 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7617 PyObject *arg2 = (PyObject *) 0 ;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "_self", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7630 }
7631 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7632 arg2 = obj1;
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 wxGridTableBase__setOORInfo(arg1,arg2);
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 resultobj = SWIG_Py_Void();
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj = 0;
7648 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7649 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 void *argp2 = 0 ;
7653 int res2 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 char * kwnames[] = {
7657 (char *) "self",(char *) "attrProvider", NULL
7658 };
7659
7660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7664 }
7665 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7667 if (!SWIG_IsOK(res2)) {
7668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7669 }
7670 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 (arg1)->SetAttrProvider(arg2);
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 resultobj = SWIG_Py_Void();
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685 PyObject *resultobj = 0;
7686 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7687 wxGridCellAttrProvider *result = 0 ;
7688 void *argp1 = 0 ;
7689 int res1 = 0 ;
7690 PyObject *swig_obj[1] ;
7691
7692 if (!args) SWIG_fail;
7693 swig_obj[0] = args;
7694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7697 }
7698 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 {
7706 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7707 }
7708 return resultobj;
7709 fail:
7710 return NULL;
7711 }
7712
7713
7714 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7715 PyObject *resultobj = 0;
7716 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7717 wxGrid *arg2 = (wxGrid *) 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 *) "grid", NULL
7726 };
7727
7728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",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_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7732 }
7733 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7735 if (!SWIG_IsOK(res2)) {
7736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7737 }
7738 arg2 = reinterpret_cast< wxGrid * >(argp2);
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 (arg1)->SetView(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_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7753 PyObject *resultobj = 0;
7754 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7755 wxGrid *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_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7765 }
7766 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 {
7774 resultobj = wxPyMake_wxObject(result, (bool)0);
7775 }
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7783 PyObject *resultobj = 0;
7784 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7785 int result;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 PyObject *swig_obj[1] ;
7789
7790 if (!args) SWIG_fail;
7791 swig_obj[0] = args;
7792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7795 }
7796 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = (int)(arg1)->GetNumberRows();
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 resultobj = SWIG_From_int(static_cast< int >(result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7811 PyObject *resultobj = 0;
7812 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7813 int result;
7814 void *argp1 = 0 ;
7815 int res1 = 0 ;
7816 PyObject *swig_obj[1] ;
7817
7818 if (!args) SWIG_fail;
7819 swig_obj[0] = args;
7820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7823 }
7824 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7825 {
7826 PyThreadState* __tstate = wxPyBeginAllowThreads();
7827 result = (int)(arg1)->GetNumberCols();
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 resultobj = SWIG_From_int(static_cast< int >(result));
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj = 0;
7840 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7841 int arg2 ;
7842 int arg3 ;
7843 bool result;
7844 void *argp1 = 0 ;
7845 int res1 = 0 ;
7846 int val2 ;
7847 int ecode2 = 0 ;
7848 int val3 ;
7849 int ecode3 = 0 ;
7850 PyObject * obj0 = 0 ;
7851 PyObject * obj1 = 0 ;
7852 PyObject * obj2 = 0 ;
7853 char * kwnames[] = {
7854 (char *) "self",(char *) "row",(char *) "col", NULL
7855 };
7856
7857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7861 }
7862 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7863 ecode2 = SWIG_AsVal_int(obj1, &val2);
7864 if (!SWIG_IsOK(ecode2)) {
7865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7866 }
7867 arg2 = static_cast< int >(val2);
7868 ecode3 = SWIG_AsVal_int(obj2, &val3);
7869 if (!SWIG_IsOK(ecode3)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7871 }
7872 arg3 = static_cast< int >(val3);
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7876 wxPyEndAllowThreads(__tstate);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 {
7880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7881 }
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = 0;
7890 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7891 int arg2 ;
7892 int arg3 ;
7893 wxString result;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 int val2 ;
7897 int ecode2 = 0 ;
7898 int val3 ;
7899 int ecode3 = 0 ;
7900 PyObject * obj0 = 0 ;
7901 PyObject * obj1 = 0 ;
7902 PyObject * obj2 = 0 ;
7903 char * kwnames[] = {
7904 (char *) "self",(char *) "row",(char *) "col", NULL
7905 };
7906
7907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7911 }
7912 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7913 ecode2 = SWIG_AsVal_int(obj1, &val2);
7914 if (!SWIG_IsOK(ecode2)) {
7915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7916 }
7917 arg2 = static_cast< int >(val2);
7918 ecode3 = SWIG_AsVal_int(obj2, &val3);
7919 if (!SWIG_IsOK(ecode3)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7921 }
7922 arg3 = static_cast< int >(val3);
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 result = (arg1)->GetValue(arg2,arg3);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 {
7930 #if wxUSE_UNICODE
7931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7932 #else
7933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7934 #endif
7935 }
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7943 PyObject *resultobj = 0;
7944 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7945 int arg2 ;
7946 int arg3 ;
7947 wxString *arg4 = 0 ;
7948 void *argp1 = 0 ;
7949 int res1 = 0 ;
7950 int val2 ;
7951 int ecode2 = 0 ;
7952 int val3 ;
7953 int ecode3 = 0 ;
7954 bool temp4 = false ;
7955 PyObject * obj0 = 0 ;
7956 PyObject * obj1 = 0 ;
7957 PyObject * obj2 = 0 ;
7958 PyObject * obj3 = 0 ;
7959 char * kwnames[] = {
7960 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7961 };
7962
7963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7967 }
7968 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7969 ecode2 = SWIG_AsVal_int(obj1, &val2);
7970 if (!SWIG_IsOK(ecode2)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
7972 }
7973 arg2 = static_cast< int >(val2);
7974 ecode3 = SWIG_AsVal_int(obj2, &val3);
7975 if (!SWIG_IsOK(ecode3)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
7977 }
7978 arg3 = static_cast< int >(val3);
7979 {
7980 arg4 = wxString_in_helper(obj3);
7981 if (arg4 == NULL) SWIG_fail;
7982 temp4 = true;
7983 }
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 resultobj = SWIG_Py_Void();
7991 {
7992 if (temp4)
7993 delete arg4;
7994 }
7995 return resultobj;
7996 fail:
7997 {
7998 if (temp4)
7999 delete arg4;
8000 }
8001 return NULL;
8002 }
8003
8004
8005 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj = 0;
8007 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8008 int arg2 ;
8009 int arg3 ;
8010 wxString result;
8011 void *argp1 = 0 ;
8012 int res1 = 0 ;
8013 int val2 ;
8014 int ecode2 = 0 ;
8015 int val3 ;
8016 int ecode3 = 0 ;
8017 PyObject * obj0 = 0 ;
8018 PyObject * obj1 = 0 ;
8019 PyObject * obj2 = 0 ;
8020 char * kwnames[] = {
8021 (char *) "self",(char *) "row",(char *) "col", NULL
8022 };
8023
8024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8026 if (!SWIG_IsOK(res1)) {
8027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8028 }
8029 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8030 ecode2 = SWIG_AsVal_int(obj1, &val2);
8031 if (!SWIG_IsOK(ecode2)) {
8032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8033 }
8034 arg2 = static_cast< int >(val2);
8035 ecode3 = SWIG_AsVal_int(obj2, &val3);
8036 if (!SWIG_IsOK(ecode3)) {
8037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8038 }
8039 arg3 = static_cast< int >(val3);
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 result = (arg1)->GetTypeName(arg2,arg3);
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 {
8047 #if wxUSE_UNICODE
8048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8049 #else
8050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8051 #endif
8052 }
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj = 0;
8061 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8062 int arg2 ;
8063 int arg3 ;
8064 wxString *arg4 = 0 ;
8065 bool result;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int val2 ;
8069 int ecode2 = 0 ;
8070 int val3 ;
8071 int ecode3 = 0 ;
8072 bool temp4 = false ;
8073 PyObject * obj0 = 0 ;
8074 PyObject * obj1 = 0 ;
8075 PyObject * obj2 = 0 ;
8076 PyObject * obj3 = 0 ;
8077 char * kwnames[] = {
8078 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8079 };
8080
8081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8083 if (!SWIG_IsOK(res1)) {
8084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8085 }
8086 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8087 ecode2 = SWIG_AsVal_int(obj1, &val2);
8088 if (!SWIG_IsOK(ecode2)) {
8089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8090 }
8091 arg2 = static_cast< int >(val2);
8092 ecode3 = SWIG_AsVal_int(obj2, &val3);
8093 if (!SWIG_IsOK(ecode3)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8095 }
8096 arg3 = static_cast< int >(val3);
8097 {
8098 arg4 = wxString_in_helper(obj3);
8099 if (arg4 == NULL) SWIG_fail;
8100 temp4 = true;
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8110 }
8111 {
8112 if (temp4)
8113 delete arg4;
8114 }
8115 return resultobj;
8116 fail:
8117 {
8118 if (temp4)
8119 delete arg4;
8120 }
8121 return NULL;
8122 }
8123
8124
8125 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8126 PyObject *resultobj = 0;
8127 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8128 int arg2 ;
8129 int arg3 ;
8130 wxString *arg4 = 0 ;
8131 bool result;
8132 void *argp1 = 0 ;
8133 int res1 = 0 ;
8134 int val2 ;
8135 int ecode2 = 0 ;
8136 int val3 ;
8137 int ecode3 = 0 ;
8138 bool temp4 = false ;
8139 PyObject * obj0 = 0 ;
8140 PyObject * obj1 = 0 ;
8141 PyObject * obj2 = 0 ;
8142 PyObject * obj3 = 0 ;
8143 char * kwnames[] = {
8144 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8145 };
8146
8147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8149 if (!SWIG_IsOK(res1)) {
8150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8151 }
8152 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8153 ecode2 = SWIG_AsVal_int(obj1, &val2);
8154 if (!SWIG_IsOK(ecode2)) {
8155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8156 }
8157 arg2 = static_cast< int >(val2);
8158 ecode3 = SWIG_AsVal_int(obj2, &val3);
8159 if (!SWIG_IsOK(ecode3)) {
8160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8161 }
8162 arg3 = static_cast< int >(val3);
8163 {
8164 arg4 = wxString_in_helper(obj3);
8165 if (arg4 == NULL) SWIG_fail;
8166 temp4 = true;
8167 }
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 {
8175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8176 }
8177 {
8178 if (temp4)
8179 delete arg4;
8180 }
8181 return resultobj;
8182 fail:
8183 {
8184 if (temp4)
8185 delete arg4;
8186 }
8187 return NULL;
8188 }
8189
8190
8191 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj = 0;
8193 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8194 int arg2 ;
8195 int arg3 ;
8196 long result;
8197 void *argp1 = 0 ;
8198 int res1 = 0 ;
8199 int val2 ;
8200 int ecode2 = 0 ;
8201 int val3 ;
8202 int ecode3 = 0 ;
8203 PyObject * obj0 = 0 ;
8204 PyObject * obj1 = 0 ;
8205 PyObject * obj2 = 0 ;
8206 char * kwnames[] = {
8207 (char *) "self",(char *) "row",(char *) "col", NULL
8208 };
8209
8210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8212 if (!SWIG_IsOK(res1)) {
8213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8214 }
8215 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8216 ecode2 = SWIG_AsVal_int(obj1, &val2);
8217 if (!SWIG_IsOK(ecode2)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8219 }
8220 arg2 = static_cast< int >(val2);
8221 ecode3 = SWIG_AsVal_int(obj2, &val3);
8222 if (!SWIG_IsOK(ecode3)) {
8223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8224 }
8225 arg3 = static_cast< int >(val3);
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_From_long(static_cast< long >(result));
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8242 int arg2 ;
8243 int arg3 ;
8244 double result;
8245 void *argp1 = 0 ;
8246 int res1 = 0 ;
8247 int val2 ;
8248 int ecode2 = 0 ;
8249 int val3 ;
8250 int ecode3 = 0 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 PyObject * obj2 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "self",(char *) "row",(char *) "col", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8260 if (!SWIG_IsOK(res1)) {
8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8262 }
8263 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8264 ecode2 = SWIG_AsVal_int(obj1, &val2);
8265 if (!SWIG_IsOK(ecode2)) {
8266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8267 }
8268 arg2 = static_cast< int >(val2);
8269 ecode3 = SWIG_AsVal_int(obj2, &val3);
8270 if (!SWIG_IsOK(ecode3)) {
8271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8272 }
8273 arg3 = static_cast< int >(val3);
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8277 wxPyEndAllowThreads(__tstate);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 resultobj = SWIG_From_double(static_cast< double >(result));
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj = 0;
8289 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8290 int arg2 ;
8291 int arg3 ;
8292 bool result;
8293 void *argp1 = 0 ;
8294 int res1 = 0 ;
8295 int val2 ;
8296 int ecode2 = 0 ;
8297 int val3 ;
8298 int ecode3 = 0 ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 PyObject * obj2 = 0 ;
8302 char * kwnames[] = {
8303 (char *) "self",(char *) "row",(char *) "col", NULL
8304 };
8305
8306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8308 if (!SWIG_IsOK(res1)) {
8309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8310 }
8311 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8312 ecode2 = SWIG_AsVal_int(obj1, &val2);
8313 if (!SWIG_IsOK(ecode2)) {
8314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8315 }
8316 arg2 = static_cast< int >(val2);
8317 ecode3 = SWIG_AsVal_int(obj2, &val3);
8318 if (!SWIG_IsOK(ecode3)) {
8319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8320 }
8321 arg3 = static_cast< int >(val3);
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8325 wxPyEndAllowThreads(__tstate);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 {
8329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8330 }
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = 0;
8339 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8340 int arg2 ;
8341 int arg3 ;
8342 long arg4 ;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 int val2 ;
8346 int ecode2 = 0 ;
8347 int val3 ;
8348 int ecode3 = 0 ;
8349 long val4 ;
8350 int ecode4 = 0 ;
8351 PyObject * obj0 = 0 ;
8352 PyObject * obj1 = 0 ;
8353 PyObject * obj2 = 0 ;
8354 PyObject * obj3 = 0 ;
8355 char * kwnames[] = {
8356 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8357 };
8358
8359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8363 }
8364 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8365 ecode2 = SWIG_AsVal_int(obj1, &val2);
8366 if (!SWIG_IsOK(ecode2)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8368 }
8369 arg2 = static_cast< int >(val2);
8370 ecode3 = SWIG_AsVal_int(obj2, &val3);
8371 if (!SWIG_IsOK(ecode3)) {
8372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8373 }
8374 arg3 = static_cast< int >(val3);
8375 ecode4 = SWIG_AsVal_long(obj3, &val4);
8376 if (!SWIG_IsOK(ecode4)) {
8377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8378 }
8379 arg4 = static_cast< long >(val4);
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_Py_Void();
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj = 0;
8395 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8396 int arg2 ;
8397 int arg3 ;
8398 double arg4 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 int val2 ;
8402 int ecode2 = 0 ;
8403 int val3 ;
8404 int ecode3 = 0 ;
8405 double val4 ;
8406 int ecode4 = 0 ;
8407 PyObject * obj0 = 0 ;
8408 PyObject * obj1 = 0 ;
8409 PyObject * obj2 = 0 ;
8410 PyObject * obj3 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8419 }
8420 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8421 ecode2 = SWIG_AsVal_int(obj1, &val2);
8422 if (!SWIG_IsOK(ecode2)) {
8423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8424 }
8425 arg2 = static_cast< int >(val2);
8426 ecode3 = SWIG_AsVal_int(obj2, &val3);
8427 if (!SWIG_IsOK(ecode3)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8429 }
8430 arg3 = static_cast< int >(val3);
8431 ecode4 = SWIG_AsVal_double(obj3, &val4);
8432 if (!SWIG_IsOK(ecode4)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8434 }
8435 arg4 = static_cast< double >(val4);
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8439 wxPyEndAllowThreads(__tstate);
8440 if (PyErr_Occurred()) SWIG_fail;
8441 }
8442 resultobj = SWIG_Py_Void();
8443 return resultobj;
8444 fail:
8445 return NULL;
8446 }
8447
8448
8449 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj = 0;
8451 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8452 int arg2 ;
8453 int arg3 ;
8454 bool arg4 ;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 int val2 ;
8458 int ecode2 = 0 ;
8459 int val3 ;
8460 int ecode3 = 0 ;
8461 bool val4 ;
8462 int ecode4 = 0 ;
8463 PyObject * obj0 = 0 ;
8464 PyObject * obj1 = 0 ;
8465 PyObject * obj2 = 0 ;
8466 PyObject * obj3 = 0 ;
8467 char * kwnames[] = {
8468 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8469 };
8470
8471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8475 }
8476 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8477 ecode2 = SWIG_AsVal_int(obj1, &val2);
8478 if (!SWIG_IsOK(ecode2)) {
8479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8480 }
8481 arg2 = static_cast< int >(val2);
8482 ecode3 = SWIG_AsVal_int(obj2, &val3);
8483 if (!SWIG_IsOK(ecode3)) {
8484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8485 }
8486 arg3 = static_cast< int >(val3);
8487 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8488 if (!SWIG_IsOK(ecode4)) {
8489 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8490 }
8491 arg4 = static_cast< bool >(val4);
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8495 wxPyEndAllowThreads(__tstate);
8496 if (PyErr_Occurred()) SWIG_fail;
8497 }
8498 resultobj = SWIG_Py_Void();
8499 return resultobj;
8500 fail:
8501 return NULL;
8502 }
8503
8504
8505 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8506 PyObject *resultobj = 0;
8507 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 PyObject *swig_obj[1] ;
8511
8512 if (!args) SWIG_fail;
8513 swig_obj[0] = args;
8514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8515 if (!SWIG_IsOK(res1)) {
8516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8517 }
8518 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 (arg1)->Clear();
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 resultobj = SWIG_Py_Void();
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj = 0;
8534 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8535 size_t arg2 = (size_t) 0 ;
8536 size_t arg3 = (size_t) 1 ;
8537 bool result;
8538 void *argp1 = 0 ;
8539 int res1 = 0 ;
8540 size_t val2 ;
8541 int ecode2 = 0 ;
8542 size_t val3 ;
8543 int ecode3 = 0 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 PyObject * obj2 = 0 ;
8547 char * kwnames[] = {
8548 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8549 };
8550
8551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8553 if (!SWIG_IsOK(res1)) {
8554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8555 }
8556 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8557 if (obj1) {
8558 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8559 if (!SWIG_IsOK(ecode2)) {
8560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8561 }
8562 arg2 = static_cast< size_t >(val2);
8563 }
8564 if (obj2) {
8565 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8566 if (!SWIG_IsOK(ecode3)) {
8567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8568 }
8569 arg3 = static_cast< size_t >(val3);
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 result = (bool)(arg1)->InsertRows(arg2,arg3);
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 {
8578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8579 }
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj = 0;
8588 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8589 size_t arg2 = (size_t) 1 ;
8590 bool result;
8591 void *argp1 = 0 ;
8592 int res1 = 0 ;
8593 size_t val2 ;
8594 int ecode2 = 0 ;
8595 PyObject * obj0 = 0 ;
8596 PyObject * obj1 = 0 ;
8597 char * kwnames[] = {
8598 (char *) "self",(char *) "numRows", NULL
8599 };
8600
8601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8603 if (!SWIG_IsOK(res1)) {
8604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8605 }
8606 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8607 if (obj1) {
8608 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8609 if (!SWIG_IsOK(ecode2)) {
8610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8611 }
8612 arg2 = static_cast< size_t >(val2);
8613 }
8614 {
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 result = (bool)(arg1)->AppendRows(arg2);
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8622 }
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8630 PyObject *resultobj = 0;
8631 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8632 size_t arg2 = (size_t) 0 ;
8633 size_t arg3 = (size_t) 1 ;
8634 bool result;
8635 void *argp1 = 0 ;
8636 int res1 = 0 ;
8637 size_t val2 ;
8638 int ecode2 = 0 ;
8639 size_t val3 ;
8640 int ecode3 = 0 ;
8641 PyObject * obj0 = 0 ;
8642 PyObject * obj1 = 0 ;
8643 PyObject * obj2 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8652 }
8653 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8654 if (obj1) {
8655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8656 if (!SWIG_IsOK(ecode2)) {
8657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8658 }
8659 arg2 = static_cast< size_t >(val2);
8660 }
8661 if (obj2) {
8662 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8663 if (!SWIG_IsOK(ecode3)) {
8664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8665 }
8666 arg3 = static_cast< size_t >(val3);
8667 }
8668 {
8669 PyThreadState* __tstate = wxPyBeginAllowThreads();
8670 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8671 wxPyEndAllowThreads(__tstate);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 {
8675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8676 }
8677 return resultobj;
8678 fail:
8679 return NULL;
8680 }
8681
8682
8683 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8684 PyObject *resultobj = 0;
8685 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8686 size_t arg2 = (size_t) 0 ;
8687 size_t arg3 = (size_t) 1 ;
8688 bool result;
8689 void *argp1 = 0 ;
8690 int res1 = 0 ;
8691 size_t val2 ;
8692 int ecode2 = 0 ;
8693 size_t val3 ;
8694 int ecode3 = 0 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 PyObject * obj2 = 0 ;
8698 char * kwnames[] = {
8699 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8700 };
8701
8702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8704 if (!SWIG_IsOK(res1)) {
8705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8706 }
8707 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8708 if (obj1) {
8709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8710 if (!SWIG_IsOK(ecode2)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8712 }
8713 arg2 = static_cast< size_t >(val2);
8714 }
8715 if (obj2) {
8716 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8717 if (!SWIG_IsOK(ecode3)) {
8718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8719 }
8720 arg3 = static_cast< size_t >(val3);
8721 }
8722 {
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 result = (bool)(arg1)->InsertCols(arg2,arg3);
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 {
8729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8730 }
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8738 PyObject *resultobj = 0;
8739 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8740 size_t arg2 = (size_t) 1 ;
8741 bool result;
8742 void *argp1 = 0 ;
8743 int res1 = 0 ;
8744 size_t val2 ;
8745 int ecode2 = 0 ;
8746 PyObject * obj0 = 0 ;
8747 PyObject * obj1 = 0 ;
8748 char * kwnames[] = {
8749 (char *) "self",(char *) "numCols", NULL
8750 };
8751
8752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8756 }
8757 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8758 if (obj1) {
8759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8760 if (!SWIG_IsOK(ecode2)) {
8761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8762 }
8763 arg2 = static_cast< size_t >(val2);
8764 }
8765 {
8766 PyThreadState* __tstate = wxPyBeginAllowThreads();
8767 result = (bool)(arg1)->AppendCols(arg2);
8768 wxPyEndAllowThreads(__tstate);
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 {
8772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8773 }
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = 0;
8782 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8783 size_t arg2 = (size_t) 0 ;
8784 size_t arg3 = (size_t) 1 ;
8785 bool result;
8786 void *argp1 = 0 ;
8787 int res1 = 0 ;
8788 size_t val2 ;
8789 int ecode2 = 0 ;
8790 size_t val3 ;
8791 int ecode3 = 0 ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 PyObject * obj2 = 0 ;
8795 char * kwnames[] = {
8796 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8797 };
8798
8799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8801 if (!SWIG_IsOK(res1)) {
8802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8803 }
8804 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8805 if (obj1) {
8806 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8807 if (!SWIG_IsOK(ecode2)) {
8808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8809 }
8810 arg2 = static_cast< size_t >(val2);
8811 }
8812 if (obj2) {
8813 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8814 if (!SWIG_IsOK(ecode3)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8816 }
8817 arg3 = static_cast< size_t >(val3);
8818 }
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8827 }
8828 return resultobj;
8829 fail:
8830 return NULL;
8831 }
8832
8833
8834 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8835 PyObject *resultobj = 0;
8836 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8837 int arg2 ;
8838 wxString result;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 int val2 ;
8842 int ecode2 = 0 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "row", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8853 }
8854 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8855 ecode2 = SWIG_AsVal_int(obj1, &val2);
8856 if (!SWIG_IsOK(ecode2)) {
8857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8858 }
8859 arg2 = static_cast< int >(val2);
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (arg1)->GetRowLabelValue(arg2);
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 #if wxUSE_UNICODE
8868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8869 #else
8870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8871 #endif
8872 }
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj = 0;
8881 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8882 int arg2 ;
8883 wxString result;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 int val2 ;
8887 int ecode2 = 0 ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char * kwnames[] = {
8891 (char *) "self",(char *) "col", NULL
8892 };
8893
8894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8896 if (!SWIG_IsOK(res1)) {
8897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8898 }
8899 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8900 ecode2 = SWIG_AsVal_int(obj1, &val2);
8901 if (!SWIG_IsOK(ecode2)) {
8902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8903 }
8904 arg2 = static_cast< int >(val2);
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (arg1)->GetColLabelValue(arg2);
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 #if wxUSE_UNICODE
8913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8914 #else
8915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8916 #endif
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj = 0;
8926 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8927 int arg2 ;
8928 wxString *arg3 = 0 ;
8929 void *argp1 = 0 ;
8930 int res1 = 0 ;
8931 int val2 ;
8932 int ecode2 = 0 ;
8933 bool temp3 = false ;
8934 PyObject * obj0 = 0 ;
8935 PyObject * obj1 = 0 ;
8936 PyObject * obj2 = 0 ;
8937 char * kwnames[] = {
8938 (char *) "self",(char *) "row",(char *) "value", NULL
8939 };
8940
8941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8943 if (!SWIG_IsOK(res1)) {
8944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8945 }
8946 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8947 ecode2 = SWIG_AsVal_int(obj1, &val2);
8948 if (!SWIG_IsOK(ecode2)) {
8949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8950 }
8951 arg2 = static_cast< int >(val2);
8952 {
8953 arg3 = wxString_in_helper(obj2);
8954 if (arg3 == NULL) SWIG_fail;
8955 temp3 = true;
8956 }
8957 {
8958 PyThreadState* __tstate = wxPyBeginAllowThreads();
8959 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_Py_Void();
8964 {
8965 if (temp3)
8966 delete arg3;
8967 }
8968 return resultobj;
8969 fail:
8970 {
8971 if (temp3)
8972 delete arg3;
8973 }
8974 return NULL;
8975 }
8976
8977
8978 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj = 0;
8980 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8981 int arg2 ;
8982 wxString *arg3 = 0 ;
8983 void *argp1 = 0 ;
8984 int res1 = 0 ;
8985 int val2 ;
8986 int ecode2 = 0 ;
8987 bool temp3 = false ;
8988 PyObject * obj0 = 0 ;
8989 PyObject * obj1 = 0 ;
8990 PyObject * obj2 = 0 ;
8991 char * kwnames[] = {
8992 (char *) "self",(char *) "col",(char *) "value", NULL
8993 };
8994
8995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8999 }
9000 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9001 ecode2 = SWIG_AsVal_int(obj1, &val2);
9002 if (!SWIG_IsOK(ecode2)) {
9003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9004 }
9005 arg2 = static_cast< int >(val2);
9006 {
9007 arg3 = wxString_in_helper(obj2);
9008 if (arg3 == NULL) SWIG_fail;
9009 temp3 = true;
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 resultobj = SWIG_Py_Void();
9018 {
9019 if (temp3)
9020 delete arg3;
9021 }
9022 return resultobj;
9023 fail:
9024 {
9025 if (temp3)
9026 delete arg3;
9027 }
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033 PyObject *resultobj = 0;
9034 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9035 bool result;
9036 void *argp1 = 0 ;
9037 int res1 = 0 ;
9038 PyObject *swig_obj[1] ;
9039
9040 if (!args) SWIG_fail;
9041 swig_obj[0] = args;
9042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9045 }
9046 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 result = (bool)(arg1)->CanHaveAttributes();
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 {
9054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9055 }
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj = 0;
9064 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9065 int arg2 ;
9066 int arg3 ;
9067 wxGridCellAttr::wxAttrKind arg4 ;
9068 wxGridCellAttr *result = 0 ;
9069 void *argp1 = 0 ;
9070 int res1 = 0 ;
9071 int val2 ;
9072 int ecode2 = 0 ;
9073 int val3 ;
9074 int ecode3 = 0 ;
9075 int val4 ;
9076 int ecode4 = 0 ;
9077 PyObject * obj0 = 0 ;
9078 PyObject * obj1 = 0 ;
9079 PyObject * obj2 = 0 ;
9080 PyObject * obj3 = 0 ;
9081 char * kwnames[] = {
9082 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9083 };
9084
9085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9087 if (!SWIG_IsOK(res1)) {
9088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9089 }
9090 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9091 ecode2 = SWIG_AsVal_int(obj1, &val2);
9092 if (!SWIG_IsOK(ecode2)) {
9093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9094 }
9095 arg2 = static_cast< int >(val2);
9096 ecode3 = SWIG_AsVal_int(obj2, &val3);
9097 if (!SWIG_IsOK(ecode3)) {
9098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9099 }
9100 arg3 = static_cast< int >(val3);
9101 ecode4 = SWIG_AsVal_int(obj3, &val4);
9102 if (!SWIG_IsOK(ecode4)) {
9103 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9104 }
9105 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 {
9113 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9114 }
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9122 PyObject *resultobj = 0;
9123 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9124 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9125 int arg3 ;
9126 int arg4 ;
9127 void *argp1 = 0 ;
9128 int res1 = 0 ;
9129 void *argp2 = 0 ;
9130 int res2 = 0 ;
9131 int val3 ;
9132 int ecode3 = 0 ;
9133 int val4 ;
9134 int ecode4 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 PyObject * obj2 = 0 ;
9138 PyObject * obj3 = 0 ;
9139 char * kwnames[] = {
9140 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9141 };
9142
9143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9145 if (!SWIG_IsOK(res1)) {
9146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9147 }
9148 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9150 if (!SWIG_IsOK(res2)) {
9151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9152 }
9153 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9154 ecode3 = SWIG_AsVal_int(obj2, &val3);
9155 if (!SWIG_IsOK(ecode3)) {
9156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9157 }
9158 arg3 = static_cast< int >(val3);
9159 ecode4 = SWIG_AsVal_int(obj3, &val4);
9160 if (!SWIG_IsOK(ecode4)) {
9161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9162 }
9163 arg4 = static_cast< int >(val4);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 (arg1)->SetAttr(arg2,arg3,arg4);
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 resultobj = SWIG_Py_Void();
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj = 0;
9179 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9180 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9181 int arg3 ;
9182 void *argp1 = 0 ;
9183 int res1 = 0 ;
9184 void *argp2 = 0 ;
9185 int res2 = 0 ;
9186 int val3 ;
9187 int ecode3 = 0 ;
9188 PyObject * obj0 = 0 ;
9189 PyObject * obj1 = 0 ;
9190 PyObject * obj2 = 0 ;
9191 char * kwnames[] = {
9192 (char *) "self",(char *) "attr",(char *) "row", NULL
9193 };
9194
9195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9197 if (!SWIG_IsOK(res1)) {
9198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9199 }
9200 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9202 if (!SWIG_IsOK(res2)) {
9203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9204 }
9205 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9206 ecode3 = SWIG_AsVal_int(obj2, &val3);
9207 if (!SWIG_IsOK(ecode3)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9209 }
9210 arg3 = static_cast< int >(val3);
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 (arg1)->SetRowAttr(arg2,arg3);
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = SWIG_Py_Void();
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = 0;
9226 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9227 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9228 int arg3 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 void *argp2 = 0 ;
9232 int res2 = 0 ;
9233 int val3 ;
9234 int ecode3 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 PyObject * obj2 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "attr",(char *) "col", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9246 }
9247 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9249 if (!SWIG_IsOK(res2)) {
9250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9251 }
9252 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9253 ecode3 = SWIG_AsVal_int(obj2, &val3);
9254 if (!SWIG_IsOK(ecode3)) {
9255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9256 }
9257 arg3 = static_cast< int >(val3);
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 (arg1)->SetColAttr(arg2,arg3);
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 resultobj = SWIG_Py_Void();
9265 return resultobj;
9266 fail:
9267 return NULL;
9268 }
9269
9270
9271 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9272 PyObject *obj;
9273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9274 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9275 return SWIG_Py_Void();
9276 }
9277
9278 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxPyGridTableBase *result = 0 ;
9281
9282 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj = 0;
9298 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9299 PyObject *arg2 = (PyObject *) 0 ;
9300 PyObject *arg3 = (PyObject *) 0 ;
9301 void *argp1 = 0 ;
9302 int res1 = 0 ;
9303 PyObject * obj0 = 0 ;
9304 PyObject * obj1 = 0 ;
9305 PyObject * obj2 = 0 ;
9306 char * kwnames[] = {
9307 (char *) "self",(char *) "self",(char *) "_class", NULL
9308 };
9309
9310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9314 }
9315 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9316 arg2 = obj1;
9317 arg3 = obj2;
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->_setCallbackInfo(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 PyObject *swig_obj[1] ;
9337
9338 if (!args) SWIG_fail;
9339 swig_obj[0] = args;
9340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9341 if (!SWIG_IsOK(res1)) {
9342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9343 }
9344 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 wxPyGridTableBase_Destroy(arg1);
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_Py_Void();
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *obj;
9360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9361 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9362 return SWIG_Py_Void();
9363 }
9364
9365 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9366 return SWIG_Python_InitShadowInstance(args);
9367 }
9368
9369 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = 0;
9371 int arg1 = (int) 0 ;
9372 int arg2 = (int) 0 ;
9373 wxGridStringTable *result = 0 ;
9374 int val1 ;
9375 int ecode1 = 0 ;
9376 int val2 ;
9377 int ecode2 = 0 ;
9378 PyObject * obj0 = 0 ;
9379 PyObject * obj1 = 0 ;
9380 char * kwnames[] = {
9381 (char *) "numRows",(char *) "numCols", NULL
9382 };
9383
9384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9385 if (obj0) {
9386 ecode1 = SWIG_AsVal_int(obj0, &val1);
9387 if (!SWIG_IsOK(ecode1)) {
9388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9389 }
9390 arg1 = static_cast< int >(val1);
9391 }
9392 if (obj1) {
9393 ecode2 = SWIG_AsVal_int(obj1, &val2);
9394 if (!SWIG_IsOK(ecode2)) {
9395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9396 }
9397 arg2 = static_cast< int >(val2);
9398 }
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9402 wxPyEndAllowThreads(__tstate);
9403 if (PyErr_Occurred()) SWIG_fail;
9404 }
9405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9406 return resultobj;
9407 fail:
9408 return NULL;
9409 }
9410
9411
9412 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9413 PyObject *obj;
9414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9415 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9416 return SWIG_Py_Void();
9417 }
9418
9419 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 return SWIG_Python_InitShadowInstance(args);
9421 }
9422
9423 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj = 0;
9425 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9426 int arg2 ;
9427 int arg3 = (int) -1 ;
9428 int arg4 = (int) -1 ;
9429 wxGridTableMessage *result = 0 ;
9430 void *argp1 = 0 ;
9431 int res1 = 0 ;
9432 int val2 ;
9433 int ecode2 = 0 ;
9434 int val3 ;
9435 int ecode3 = 0 ;
9436 int val4 ;
9437 int ecode4 = 0 ;
9438 PyObject * obj0 = 0 ;
9439 PyObject * obj1 = 0 ;
9440 PyObject * obj2 = 0 ;
9441 PyObject * obj3 = 0 ;
9442 char * kwnames[] = {
9443 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9444 };
9445
9446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9448 if (!SWIG_IsOK(res1)) {
9449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9450 }
9451 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9452 ecode2 = SWIG_AsVal_int(obj1, &val2);
9453 if (!SWIG_IsOK(ecode2)) {
9454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9455 }
9456 arg2 = static_cast< int >(val2);
9457 if (obj2) {
9458 ecode3 = SWIG_AsVal_int(obj2, &val3);
9459 if (!SWIG_IsOK(ecode3)) {
9460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9461 }
9462 arg3 = static_cast< int >(val3);
9463 }
9464 if (obj3) {
9465 ecode4 = SWIG_AsVal_int(obj3, &val4);
9466 if (!SWIG_IsOK(ecode4)) {
9467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9468 }
9469 arg4 = static_cast< int >(val4);
9470 }
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 PyObject *resultobj = 0;
9486 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9487 void *argp1 = 0 ;
9488 int res1 = 0 ;
9489 PyObject *swig_obj[1] ;
9490
9491 if (!args) SWIG_fail;
9492 swig_obj[0] = args;
9493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9494 if (!SWIG_IsOK(res1)) {
9495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9496 }
9497 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 delete arg1;
9501
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 resultobj = SWIG_Py_Void();
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9513 PyObject *resultobj = 0;
9514 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9515 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 void *argp2 = 0 ;
9519 int res2 = 0 ;
9520 PyObject * obj0 = 0 ;
9521 PyObject * obj1 = 0 ;
9522 char * kwnames[] = {
9523 (char *) "self",(char *) "table", NULL
9524 };
9525
9526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9530 }
9531 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9533 if (!SWIG_IsOK(res2)) {
9534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9535 }
9536 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 (arg1)->SetTableObject(arg2);
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_Py_Void();
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9551 PyObject *resultobj = 0;
9552 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9553 wxGridTableBase *result = 0 ;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 PyObject *swig_obj[1] ;
9557
9558 if (!args) SWIG_fail;
9559 swig_obj[0] = args;
9560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9561 if (!SWIG_IsOK(res1)) {
9562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9563 }
9564 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 {
9572 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9573 }
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = 0;
9582 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9583 int arg2 ;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 int val2 ;
9587 int ecode2 = 0 ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9590 char * kwnames[] = {
9591 (char *) "self",(char *) "id", NULL
9592 };
9593
9594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",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_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9598 }
9599 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9600 ecode2 = SWIG_AsVal_int(obj1, &val2);
9601 if (!SWIG_IsOK(ecode2)) {
9602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9603 }
9604 arg2 = static_cast< int >(val2);
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 (arg1)->SetId(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_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9621 int result;
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_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9631 }
9632 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (int)(arg1)->GetId();
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_From_int(static_cast< int >(result));
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj = 0;
9648 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9649 int arg2 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 int val2 ;
9653 int ecode2 = 0 ;
9654 PyObject * obj0 = 0 ;
9655 PyObject * obj1 = 0 ;
9656 char * kwnames[] = {
9657 (char *) "self",(char *) "comInt1", NULL
9658 };
9659
9660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9664 }
9665 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9666 ecode2 = SWIG_AsVal_int(obj1, &val2);
9667 if (!SWIG_IsOK(ecode2)) {
9668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9669 }
9670 arg2 = static_cast< int >(val2);
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 (arg1)->SetCommandInt(arg2);
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 resultobj = SWIG_Py_Void();
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9685 PyObject *resultobj = 0;
9686 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9687 int result;
9688 void *argp1 = 0 ;
9689 int res1 = 0 ;
9690 PyObject *swig_obj[1] ;
9691
9692 if (!args) SWIG_fail;
9693 swig_obj[0] = args;
9694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9695 if (!SWIG_IsOK(res1)) {
9696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9697 }
9698 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 result = (int)(arg1)->GetCommandInt();
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_From_int(static_cast< int >(result));
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj = 0;
9714 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9715 int arg2 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 int val2 ;
9719 int ecode2 = 0 ;
9720 PyObject * obj0 = 0 ;
9721 PyObject * obj1 = 0 ;
9722 char * kwnames[] = {
9723 (char *) "self",(char *) "comInt2", NULL
9724 };
9725
9726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9730 }
9731 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9732 ecode2 = SWIG_AsVal_int(obj1, &val2);
9733 if (!SWIG_IsOK(ecode2)) {
9734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9735 }
9736 arg2 = static_cast< int >(val2);
9737 {
9738 PyThreadState* __tstate = wxPyBeginAllowThreads();
9739 (arg1)->SetCommandInt2(arg2);
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 resultobj = SWIG_Py_Void();
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9751 PyObject *resultobj = 0;
9752 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9753 int result;
9754 void *argp1 = 0 ;
9755 int res1 = 0 ;
9756 PyObject *swig_obj[1] ;
9757
9758 if (!args) SWIG_fail;
9759 swig_obj[0] = args;
9760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9761 if (!SWIG_IsOK(res1)) {
9762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9763 }
9764 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (int)(arg1)->GetCommandInt2();
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_From_int(static_cast< int >(result));
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9779 PyObject *obj;
9780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9781 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9782 return SWIG_Py_Void();
9783 }
9784
9785 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9786 return SWIG_Python_InitShadowInstance(args);
9787 }
9788
9789 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj = 0;
9791 int arg1 = (int) -1 ;
9792 int arg2 = (int) -1 ;
9793 wxGridCellCoords *result = 0 ;
9794 int val1 ;
9795 int ecode1 = 0 ;
9796 int val2 ;
9797 int ecode2 = 0 ;
9798 PyObject * obj0 = 0 ;
9799 PyObject * obj1 = 0 ;
9800 char * kwnames[] = {
9801 (char *) "r",(char *) "c", NULL
9802 };
9803
9804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9805 if (obj0) {
9806 ecode1 = SWIG_AsVal_int(obj0, &val1);
9807 if (!SWIG_IsOK(ecode1)) {
9808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9809 }
9810 arg1 = static_cast< int >(val1);
9811 }
9812 if (obj1) {
9813 ecode2 = SWIG_AsVal_int(obj1, &val2);
9814 if (!SWIG_IsOK(ecode2)) {
9815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9816 }
9817 arg2 = static_cast< int >(val2);
9818 }
9819 {
9820 PyThreadState* __tstate = wxPyBeginAllowThreads();
9821 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9844 }
9845 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 delete arg1;
9849
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 resultobj = SWIG_Py_Void();
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9861 PyObject *resultobj = 0;
9862 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9863 int result;
9864 void *argp1 = 0 ;
9865 int res1 = 0 ;
9866 PyObject *swig_obj[1] ;
9867
9868 if (!args) SWIG_fail;
9869 swig_obj[0] = args;
9870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9871 if (!SWIG_IsOK(res1)) {
9872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9873 }
9874 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 resultobj = SWIG_From_int(static_cast< int >(result));
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj = 0;
9890 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9891 int arg2 ;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 int val2 ;
9895 int ecode2 = 0 ;
9896 PyObject * obj0 = 0 ;
9897 PyObject * obj1 = 0 ;
9898 char * kwnames[] = {
9899 (char *) "self",(char *) "n", NULL
9900 };
9901
9902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9904 if (!SWIG_IsOK(res1)) {
9905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9906 }
9907 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9908 ecode2 = SWIG_AsVal_int(obj1, &val2);
9909 if (!SWIG_IsOK(ecode2)) {
9910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9911 }
9912 arg2 = static_cast< int >(val2);
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 (arg1)->SetRow(arg2);
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_Py_Void();
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9927 PyObject *resultobj = 0;
9928 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9929 int result;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 PyObject *swig_obj[1] ;
9933
9934 if (!args) SWIG_fail;
9935 swig_obj[0] = args;
9936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9939 }
9940 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_From_int(static_cast< int >(result));
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj = 0;
9956 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9957 int arg2 ;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 int val2 ;
9961 int ecode2 = 0 ;
9962 PyObject * obj0 = 0 ;
9963 PyObject * obj1 = 0 ;
9964 char * kwnames[] = {
9965 (char *) "self",(char *) "n", NULL
9966 };
9967
9968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
9969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9970 if (!SWIG_IsOK(res1)) {
9971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9972 }
9973 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9974 ecode2 = SWIG_AsVal_int(obj1, &val2);
9975 if (!SWIG_IsOK(ecode2)) {
9976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
9977 }
9978 arg2 = static_cast< int >(val2);
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 (arg1)->SetCol(arg2);
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 resultobj = SWIG_Py_Void();
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj = 0;
9994 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9995 int arg2 ;
9996 int arg3 ;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 int val2 ;
10000 int ecode2 = 0 ;
10001 int val3 ;
10002 int ecode3 = 0 ;
10003 PyObject * obj0 = 0 ;
10004 PyObject * obj1 = 0 ;
10005 PyObject * obj2 = 0 ;
10006 char * kwnames[] = {
10007 (char *) "self",(char *) "row",(char *) "col", NULL
10008 };
10009
10010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10012 if (!SWIG_IsOK(res1)) {
10013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10014 }
10015 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10016 ecode2 = SWIG_AsVal_int(obj1, &val2);
10017 if (!SWIG_IsOK(ecode2)) {
10018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10019 }
10020 arg2 = static_cast< int >(val2);
10021 ecode3 = SWIG_AsVal_int(obj2, &val3);
10022 if (!SWIG_IsOK(ecode3)) {
10023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10024 }
10025 arg3 = static_cast< int >(val3);
10026 {
10027 PyThreadState* __tstate = wxPyBeginAllowThreads();
10028 (arg1)->Set(arg2,arg3);
10029 wxPyEndAllowThreads(__tstate);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 resultobj = SWIG_Py_Void();
10033 return resultobj;
10034 fail:
10035 return NULL;
10036 }
10037
10038
10039 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj = 0;
10041 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10042 PyObject *arg2 = (PyObject *) 0 ;
10043 bool result;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 char * kwnames[] = {
10049 (char *) "self",(char *) "other", NULL
10050 };
10051
10052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10056 }
10057 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10058 arg2 = obj1;
10059 {
10060 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 {
10064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10065 }
10066 return resultobj;
10067 fail:
10068 return NULL;
10069 }
10070
10071
10072 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10073 PyObject *resultobj = 0;
10074 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10075 PyObject *arg2 = (PyObject *) 0 ;
10076 bool result;
10077 void *argp1 = 0 ;
10078 int res1 = 0 ;
10079 PyObject * obj0 = 0 ;
10080 PyObject * obj1 = 0 ;
10081 char * kwnames[] = {
10082 (char *) "self",(char *) "other", NULL
10083 };
10084
10085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10087 if (!SWIG_IsOK(res1)) {
10088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10089 }
10090 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10091 arg2 = obj1;
10092 {
10093 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 {
10097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10098 }
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10106 PyObject *resultobj = 0;
10107 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10108 PyObject *result = 0 ;
10109 void *argp1 = 0 ;
10110 int res1 = 0 ;
10111 PyObject *swig_obj[1] ;
10112
10113 if (!args) SWIG_fail;
10114 swig_obj[0] = args;
10115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10118 }
10119 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 result = (PyObject *)wxGridCellCoords_Get(arg1);
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 resultobj = result;
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 PyObject *obj;
10135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10137 return SWIG_Py_Void();
10138 }
10139
10140 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 return SWIG_Python_InitShadowInstance(args);
10142 }
10143
10144 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10145 PyObject *resultobj = 0;
10146 wxWindow *arg1 = (wxWindow *) 0 ;
10147 int arg2 = (int) -1 ;
10148 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10149 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10150 wxSize const &arg4_defvalue = wxDefaultSize ;
10151 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10152 long arg5 = (long) wxWANTS_CHARS ;
10153 wxString const &arg6_defvalue = wxPyGridNameStr ;
10154 wxString *arg6 = (wxString *) &arg6_defvalue ;
10155 wxGrid *result = 0 ;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 int val2 ;
10159 int ecode2 = 0 ;
10160 wxPoint temp3 ;
10161 wxSize temp4 ;
10162 long val5 ;
10163 int ecode5 = 0 ;
10164 bool temp6 = false ;
10165 PyObject * obj0 = 0 ;
10166 PyObject * obj1 = 0 ;
10167 PyObject * obj2 = 0 ;
10168 PyObject * obj3 = 0 ;
10169 PyObject * obj4 = 0 ;
10170 PyObject * obj5 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10179 }
10180 arg1 = reinterpret_cast< wxWindow * >(argp1);
10181 if (obj1) {
10182 ecode2 = SWIG_AsVal_int(obj1, &val2);
10183 if (!SWIG_IsOK(ecode2)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10185 }
10186 arg2 = static_cast< int >(val2);
10187 }
10188 if (obj2) {
10189 {
10190 arg3 = &temp3;
10191 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10192 }
10193 }
10194 if (obj3) {
10195 {
10196 arg4 = &temp4;
10197 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10198 }
10199 }
10200 if (obj4) {
10201 ecode5 = SWIG_AsVal_long(obj4, &val5);
10202 if (!SWIG_IsOK(ecode5)) {
10203 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10204 }
10205 arg5 = static_cast< long >(val5);
10206 }
10207 if (obj5) {
10208 {
10209 arg6 = wxString_in_helper(obj5);
10210 if (arg6 == NULL) SWIG_fail;
10211 temp6 = true;
10212 }
10213 }
10214 {
10215 if (!wxPyCheckForApp()) SWIG_fail;
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10222 {
10223 if (temp6)
10224 delete arg6;
10225 }
10226 return resultobj;
10227 fail:
10228 {
10229 if (temp6)
10230 delete arg6;
10231 }
10232 return NULL;
10233 }
10234
10235
10236 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10237 PyObject *resultobj = 0;
10238 wxGrid *result = 0 ;
10239
10240 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10241 {
10242 if (!wxPyCheckForApp()) SWIG_fail;
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 result = (wxGrid *)new wxGrid();
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10256 PyObject *resultobj = 0;
10257 wxGrid *arg1 = (wxGrid *) 0 ;
10258 wxWindow *arg2 = (wxWindow *) 0 ;
10259 int arg3 = (int) -1 ;
10260 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10261 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10262 wxSize const &arg5_defvalue = wxDefaultSize ;
10263 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10264 long arg6 = (long) wxWANTS_CHARS ;
10265 wxString const &arg7_defvalue = wxPyGridNameStr ;
10266 wxString *arg7 = (wxString *) &arg7_defvalue ;
10267 bool result;
10268 void *argp1 = 0 ;
10269 int res1 = 0 ;
10270 void *argp2 = 0 ;
10271 int res2 = 0 ;
10272 int val3 ;
10273 int ecode3 = 0 ;
10274 wxPoint temp4 ;
10275 wxSize temp5 ;
10276 long val6 ;
10277 int ecode6 = 0 ;
10278 bool temp7 = false ;
10279 PyObject * obj0 = 0 ;
10280 PyObject * obj1 = 0 ;
10281 PyObject * obj2 = 0 ;
10282 PyObject * obj3 = 0 ;
10283 PyObject * obj4 = 0 ;
10284 PyObject * obj5 = 0 ;
10285 PyObject * obj6 = 0 ;
10286 char * kwnames[] = {
10287 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10288 };
10289
10290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10292 if (!SWIG_IsOK(res1)) {
10293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10294 }
10295 arg1 = reinterpret_cast< wxGrid * >(argp1);
10296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10297 if (!SWIG_IsOK(res2)) {
10298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10299 }
10300 arg2 = reinterpret_cast< wxWindow * >(argp2);
10301 if (obj2) {
10302 ecode3 = SWIG_AsVal_int(obj2, &val3);
10303 if (!SWIG_IsOK(ecode3)) {
10304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10305 }
10306 arg3 = static_cast< int >(val3);
10307 }
10308 if (obj3) {
10309 {
10310 arg4 = &temp4;
10311 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10312 }
10313 }
10314 if (obj4) {
10315 {
10316 arg5 = &temp5;
10317 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10318 }
10319 }
10320 if (obj5) {
10321 ecode6 = SWIG_AsVal_long(obj5, &val6);
10322 if (!SWIG_IsOK(ecode6)) {
10323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10324 }
10325 arg6 = static_cast< long >(val6);
10326 }
10327 if (obj6) {
10328 {
10329 arg7 = wxString_in_helper(obj6);
10330 if (arg7 == NULL) SWIG_fail;
10331 temp7 = true;
10332 }
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 {
10341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10342 }
10343 {
10344 if (temp7)
10345 delete arg7;
10346 }
10347 return resultobj;
10348 fail:
10349 {
10350 if (temp7)
10351 delete arg7;
10352 }
10353 return NULL;
10354 }
10355
10356
10357 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10358 PyObject *resultobj = 0;
10359 wxGrid *arg1 = (wxGrid *) 0 ;
10360 int arg2 ;
10361 int arg3 ;
10362 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10363 bool result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 int val2 ;
10367 int ecode2 = 0 ;
10368 int val3 ;
10369 int ecode3 = 0 ;
10370 int val4 ;
10371 int ecode4 = 0 ;
10372 PyObject * obj0 = 0 ;
10373 PyObject * obj1 = 0 ;
10374 PyObject * obj2 = 0 ;
10375 PyObject * obj3 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10384 }
10385 arg1 = reinterpret_cast< wxGrid * >(argp1);
10386 ecode2 = SWIG_AsVal_int(obj1, &val2);
10387 if (!SWIG_IsOK(ecode2)) {
10388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10389 }
10390 arg2 = static_cast< int >(val2);
10391 ecode3 = SWIG_AsVal_int(obj2, &val3);
10392 if (!SWIG_IsOK(ecode3)) {
10393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10394 }
10395 arg3 = static_cast< int >(val3);
10396 if (obj3) {
10397 ecode4 = SWIG_AsVal_int(obj3, &val4);
10398 if (!SWIG_IsOK(ecode4)) {
10399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10400 }
10401 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10402 }
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10406 wxPyEndAllowThreads(__tstate);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 {
10410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10411 }
10412 return resultobj;
10413 fail:
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj = 0;
10420 wxGrid *arg1 = (wxGrid *) 0 ;
10421 WXGRIDSELECTIONMODES arg2 ;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 int val2 ;
10425 int ecode2 = 0 ;
10426 PyObject * obj0 = 0 ;
10427 PyObject * obj1 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "selmode", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10436 }
10437 arg1 = reinterpret_cast< wxGrid * >(argp1);
10438 ecode2 = SWIG_AsVal_int(obj1, &val2);
10439 if (!SWIG_IsOK(ecode2)) {
10440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10441 }
10442 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10443 {
10444 PyThreadState* __tstate = wxPyBeginAllowThreads();
10445 (arg1)->SetSelectionMode(arg2);
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 resultobj = SWIG_Py_Void();
10450 return resultobj;
10451 fail:
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457 PyObject *resultobj = 0;
10458 wxGrid *arg1 = (wxGrid *) 0 ;
10459 WXGRIDSELECTIONMODES result;
10460 void *argp1 = 0 ;
10461 int res1 = 0 ;
10462 PyObject *swig_obj[1] ;
10463
10464 if (!args) SWIG_fail;
10465 swig_obj[0] = args;
10466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10469 }
10470 arg1 = reinterpret_cast< wxGrid * >(argp1);
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 resultobj = SWIG_From_int(static_cast< int >(result));
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxGrid *arg1 = (wxGrid *) 0 ;
10487 int result;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10497 }
10498 arg1 = reinterpret_cast< wxGrid * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (int)(arg1)->GetNumberRows();
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_From_int(static_cast< int >(result));
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10513 PyObject *resultobj = 0;
10514 wxGrid *arg1 = (wxGrid *) 0 ;
10515 int result;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 PyObject *swig_obj[1] ;
10519
10520 if (!args) SWIG_fail;
10521 swig_obj[0] = args;
10522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10525 }
10526 arg1 = reinterpret_cast< wxGrid * >(argp1);
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 result = (int)(arg1)->GetNumberCols();
10530 wxPyEndAllowThreads(__tstate);
10531 if (PyErr_Occurred()) SWIG_fail;
10532 }
10533 resultobj = SWIG_From_int(static_cast< int >(result));
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10541 PyObject *resultobj = 0;
10542 wxGrid *arg1 = (wxGrid *) 0 ;
10543 wxGridTableMessage *arg2 = 0 ;
10544 bool result;
10545 void *argp1 = 0 ;
10546 int res1 = 0 ;
10547 void *argp2 = 0 ;
10548 int res2 = 0 ;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 char * kwnames[] = {
10552 (char *) "self",(char *)"arg2", NULL
10553 };
10554
10555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10557 if (!SWIG_IsOK(res1)) {
10558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10559 }
10560 arg1 = reinterpret_cast< wxGrid * >(argp1);
10561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10562 if (!SWIG_IsOK(res2)) {
10563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10564 }
10565 if (!argp2) {
10566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10567 }
10568 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10569 {
10570 PyThreadState* __tstate = wxPyBeginAllowThreads();
10571 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 {
10576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10585 PyObject *resultobj = 0;
10586 wxGrid *arg1 = (wxGrid *) 0 ;
10587 wxGridTableBase *result = 0 ;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 PyObject *swig_obj[1] ;
10591
10592 if (!args) SWIG_fail;
10593 swig_obj[0] = args;
10594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10595 if (!SWIG_IsOK(res1)) {
10596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10597 }
10598 arg1 = reinterpret_cast< wxGrid * >(argp1);
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 {
10606 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10607 }
10608 return resultobj;
10609 fail:
10610 return NULL;
10611 }
10612
10613
10614 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10615 PyObject *resultobj = 0;
10616 wxGrid *arg1 = (wxGrid *) 0 ;
10617 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10618 bool arg3 = (bool) false ;
10619 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10620 bool result;
10621 void *argp1 = 0 ;
10622 int res1 = 0 ;
10623 int res2 = 0 ;
10624 bool val3 ;
10625 int ecode3 = 0 ;
10626 int val4 ;
10627 int ecode4 = 0 ;
10628 PyObject * obj0 = 0 ;
10629 PyObject * obj1 = 0 ;
10630 PyObject * obj2 = 0 ;
10631 PyObject * obj3 = 0 ;
10632 char * kwnames[] = {
10633 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10634 };
10635
10636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10638 if (!SWIG_IsOK(res1)) {
10639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10640 }
10641 arg1 = reinterpret_cast< wxGrid * >(argp1);
10642 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10643 if (!SWIG_IsOK(res2)) {
10644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10645 }
10646 if (obj2) {
10647 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10648 if (!SWIG_IsOK(ecode3)) {
10649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10650 }
10651 arg3 = static_cast< bool >(val3);
10652 }
10653 if (obj3) {
10654 ecode4 = SWIG_AsVal_int(obj3, &val4);
10655 if (!SWIG_IsOK(ecode4)) {
10656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10657 }
10658 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10659 }
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 {
10667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10668 }
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10676 PyObject *resultobj = 0;
10677 wxGrid *arg1 = (wxGrid *) 0 ;
10678 void *argp1 = 0 ;
10679 int res1 = 0 ;
10680 PyObject *swig_obj[1] ;
10681
10682 if (!args) SWIG_fail;
10683 swig_obj[0] = args;
10684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10687 }
10688 arg1 = reinterpret_cast< wxGrid * >(argp1);
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 (arg1)->ClearGrid();
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_Py_Void();
10696 return resultobj;
10697 fail:
10698 return NULL;
10699 }
10700
10701
10702 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10703 PyObject *resultobj = 0;
10704 wxGrid *arg1 = (wxGrid *) 0 ;
10705 int arg2 = (int) 0 ;
10706 int arg3 = (int) 1 ;
10707 bool arg4 = (bool) true ;
10708 bool result;
10709 void *argp1 = 0 ;
10710 int res1 = 0 ;
10711 int val2 ;
10712 int ecode2 = 0 ;
10713 int val3 ;
10714 int ecode3 = 0 ;
10715 bool val4 ;
10716 int ecode4 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 PyObject * obj3 = 0 ;
10721 char * kwnames[] = {
10722 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10723 };
10724
10725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10727 if (!SWIG_IsOK(res1)) {
10728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10729 }
10730 arg1 = reinterpret_cast< wxGrid * >(argp1);
10731 if (obj1) {
10732 ecode2 = SWIG_AsVal_int(obj1, &val2);
10733 if (!SWIG_IsOK(ecode2)) {
10734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10735 }
10736 arg2 = static_cast< int >(val2);
10737 }
10738 if (obj2) {
10739 ecode3 = SWIG_AsVal_int(obj2, &val3);
10740 if (!SWIG_IsOK(ecode3)) {
10741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10742 }
10743 arg3 = static_cast< int >(val3);
10744 }
10745 if (obj3) {
10746 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10747 if (!SWIG_IsOK(ecode4)) {
10748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10749 }
10750 arg4 = static_cast< bool >(val4);
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 {
10759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10760 }
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj = 0;
10769 wxGrid *arg1 = (wxGrid *) 0 ;
10770 int arg2 = (int) 1 ;
10771 bool arg3 = (bool) true ;
10772 bool result;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 int val2 ;
10776 int ecode2 = 0 ;
10777 bool val3 ;
10778 int ecode3 = 0 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 PyObject * obj2 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10790 }
10791 arg1 = reinterpret_cast< wxGrid * >(argp1);
10792 if (obj1) {
10793 ecode2 = SWIG_AsVal_int(obj1, &val2);
10794 if (!SWIG_IsOK(ecode2)) {
10795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10796 }
10797 arg2 = static_cast< int >(val2);
10798 }
10799 if (obj2) {
10800 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10801 if (!SWIG_IsOK(ecode3)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10803 }
10804 arg3 = static_cast< bool >(val3);
10805 }
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 result = (bool)(arg1)->AppendRows(arg2,arg3);
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 {
10813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10814 }
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj = 0;
10823 wxGrid *arg1 = (wxGrid *) 0 ;
10824 int arg2 = (int) 0 ;
10825 int arg3 = (int) 1 ;
10826 bool arg4 = (bool) true ;
10827 bool result;
10828 void *argp1 = 0 ;
10829 int res1 = 0 ;
10830 int val2 ;
10831 int ecode2 = 0 ;
10832 int val3 ;
10833 int ecode3 = 0 ;
10834 bool val4 ;
10835 int ecode4 = 0 ;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 PyObject * obj2 = 0 ;
10839 PyObject * obj3 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10846 if (!SWIG_IsOK(res1)) {
10847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10848 }
10849 arg1 = reinterpret_cast< wxGrid * >(argp1);
10850 if (obj1) {
10851 ecode2 = SWIG_AsVal_int(obj1, &val2);
10852 if (!SWIG_IsOK(ecode2)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10854 }
10855 arg2 = static_cast< int >(val2);
10856 }
10857 if (obj2) {
10858 ecode3 = SWIG_AsVal_int(obj2, &val3);
10859 if (!SWIG_IsOK(ecode3)) {
10860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10861 }
10862 arg3 = static_cast< int >(val3);
10863 }
10864 if (obj3) {
10865 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10866 if (!SWIG_IsOK(ecode4)) {
10867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10868 }
10869 arg4 = static_cast< bool >(val4);
10870 }
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10879 }
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj = 0;
10888 wxGrid *arg1 = (wxGrid *) 0 ;
10889 int arg2 = (int) 0 ;
10890 int arg3 = (int) 1 ;
10891 bool arg4 = (bool) true ;
10892 bool result;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 int val2 ;
10896 int ecode2 = 0 ;
10897 int val3 ;
10898 int ecode3 = 0 ;
10899 bool val4 ;
10900 int ecode4 = 0 ;
10901 PyObject * obj0 = 0 ;
10902 PyObject * obj1 = 0 ;
10903 PyObject * obj2 = 0 ;
10904 PyObject * obj3 = 0 ;
10905 char * kwnames[] = {
10906 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10907 };
10908
10909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10911 if (!SWIG_IsOK(res1)) {
10912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10913 }
10914 arg1 = reinterpret_cast< wxGrid * >(argp1);
10915 if (obj1) {
10916 ecode2 = SWIG_AsVal_int(obj1, &val2);
10917 if (!SWIG_IsOK(ecode2)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10919 }
10920 arg2 = static_cast< int >(val2);
10921 }
10922 if (obj2) {
10923 ecode3 = SWIG_AsVal_int(obj2, &val3);
10924 if (!SWIG_IsOK(ecode3)) {
10925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10926 }
10927 arg3 = static_cast< int >(val3);
10928 }
10929 if (obj3) {
10930 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10931 if (!SWIG_IsOK(ecode4)) {
10932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10933 }
10934 arg4 = static_cast< bool >(val4);
10935 }
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 {
10943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10944 }
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxGrid *arg1 = (wxGrid *) 0 ;
10954 int arg2 = (int) 1 ;
10955 bool arg3 = (bool) true ;
10956 bool result;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 int val2 ;
10960 int ecode2 = 0 ;
10961 bool val3 ;
10962 int ecode3 = 0 ;
10963 PyObject * obj0 = 0 ;
10964 PyObject * obj1 = 0 ;
10965 PyObject * obj2 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10974 }
10975 arg1 = reinterpret_cast< wxGrid * >(argp1);
10976 if (obj1) {
10977 ecode2 = SWIG_AsVal_int(obj1, &val2);
10978 if (!SWIG_IsOK(ecode2)) {
10979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
10980 }
10981 arg2 = static_cast< int >(val2);
10982 }
10983 if (obj2) {
10984 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10985 if (!SWIG_IsOK(ecode3)) {
10986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
10987 }
10988 arg3 = static_cast< bool >(val3);
10989 }
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (bool)(arg1)->AppendCols(arg2,arg3);
10993 wxPyEndAllowThreads(__tstate);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 {
10997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10998 }
10999 return resultobj;
11000 fail:
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj = 0;
11007 wxGrid *arg1 = (wxGrid *) 0 ;
11008 int arg2 = (int) 0 ;
11009 int arg3 = (int) 1 ;
11010 bool arg4 = (bool) true ;
11011 bool result;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 int val2 ;
11015 int ecode2 = 0 ;
11016 int val3 ;
11017 int ecode3 = 0 ;
11018 bool val4 ;
11019 int ecode4 = 0 ;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 PyObject * obj3 = 0 ;
11024 char * kwnames[] = {
11025 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11026 };
11027
11028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11032 }
11033 arg1 = reinterpret_cast< wxGrid * >(argp1);
11034 if (obj1) {
11035 ecode2 = SWIG_AsVal_int(obj1, &val2);
11036 if (!SWIG_IsOK(ecode2)) {
11037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11038 }
11039 arg2 = static_cast< int >(val2);
11040 }
11041 if (obj2) {
11042 ecode3 = SWIG_AsVal_int(obj2, &val3);
11043 if (!SWIG_IsOK(ecode3)) {
11044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11045 }
11046 arg3 = static_cast< int >(val3);
11047 }
11048 if (obj3) {
11049 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11050 if (!SWIG_IsOK(ecode4)) {
11051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11052 }
11053 arg4 = static_cast< bool >(val4);
11054 }
11055 {
11056 PyThreadState* __tstate = wxPyBeginAllowThreads();
11057 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11058 wxPyEndAllowThreads(__tstate);
11059 if (PyErr_Occurred()) SWIG_fail;
11060 }
11061 {
11062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11063 }
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11071 PyObject *resultobj = 0;
11072 wxGrid *arg1 = (wxGrid *) 0 ;
11073 wxDC *arg2 = 0 ;
11074 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11075 void *argp1 = 0 ;
11076 int res1 = 0 ;
11077 void *argp2 = 0 ;
11078 int res2 = 0 ;
11079 void *argp3 = 0 ;
11080 int res3 = 0 ;
11081 PyObject * obj0 = 0 ;
11082 PyObject * obj1 = 0 ;
11083 PyObject * obj2 = 0 ;
11084 char * kwnames[] = {
11085 (char *) "self",(char *) "dc",(char *) "attr", NULL
11086 };
11087
11088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11090 if (!SWIG_IsOK(res1)) {
11091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11092 }
11093 arg1 = reinterpret_cast< wxGrid * >(argp1);
11094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11095 if (!SWIG_IsOK(res2)) {
11096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11097 }
11098 if (!argp2) {
11099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11100 }
11101 arg2 = reinterpret_cast< wxDC * >(argp2);
11102 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11103 if (!SWIG_IsOK(res3)) {
11104 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11105 }
11106 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11107 {
11108 PyThreadState* __tstate = wxPyBeginAllowThreads();
11109 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11110 wxPyEndAllowThreads(__tstate);
11111 if (PyErr_Occurred()) SWIG_fail;
11112 }
11113 resultobj = SWIG_Py_Void();
11114 return resultobj;
11115 fail:
11116 return NULL;
11117 }
11118
11119
11120 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11121 PyObject *resultobj = 0;
11122 wxGrid *arg1 = (wxGrid *) 0 ;
11123 wxDC *arg2 = 0 ;
11124 wxString *arg3 = 0 ;
11125 wxRect *arg4 = 0 ;
11126 int arg5 = (int) wxLEFT ;
11127 int arg6 = (int) wxTOP ;
11128 int arg7 = (int) wxHORIZONTAL ;
11129 void *argp1 = 0 ;
11130 int res1 = 0 ;
11131 void *argp2 = 0 ;
11132 int res2 = 0 ;
11133 bool temp3 = false ;
11134 wxRect temp4 ;
11135 int val5 ;
11136 int ecode5 = 0 ;
11137 int val6 ;
11138 int ecode6 = 0 ;
11139 int val7 ;
11140 int ecode7 = 0 ;
11141 PyObject * obj0 = 0 ;
11142 PyObject * obj1 = 0 ;
11143 PyObject * obj2 = 0 ;
11144 PyObject * obj3 = 0 ;
11145 PyObject * obj4 = 0 ;
11146 PyObject * obj5 = 0 ;
11147 PyObject * obj6 = 0 ;
11148 char * kwnames[] = {
11149 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11150 };
11151
11152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11154 if (!SWIG_IsOK(res1)) {
11155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11156 }
11157 arg1 = reinterpret_cast< wxGrid * >(argp1);
11158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11159 if (!SWIG_IsOK(res2)) {
11160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11161 }
11162 if (!argp2) {
11163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11164 }
11165 arg2 = reinterpret_cast< wxDC * >(argp2);
11166 {
11167 arg3 = wxString_in_helper(obj2);
11168 if (arg3 == NULL) SWIG_fail;
11169 temp3 = true;
11170 }
11171 {
11172 arg4 = &temp4;
11173 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11174 }
11175 if (obj4) {
11176 ecode5 = SWIG_AsVal_int(obj4, &val5);
11177 if (!SWIG_IsOK(ecode5)) {
11178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11179 }
11180 arg5 = static_cast< int >(val5);
11181 }
11182 if (obj5) {
11183 ecode6 = SWIG_AsVal_int(obj5, &val6);
11184 if (!SWIG_IsOK(ecode6)) {
11185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11186 }
11187 arg6 = static_cast< int >(val6);
11188 }
11189 if (obj6) {
11190 ecode7 = SWIG_AsVal_int(obj6, &val7);
11191 if (!SWIG_IsOK(ecode7)) {
11192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11193 }
11194 arg7 = static_cast< int >(val7);
11195 }
11196 {
11197 PyThreadState* __tstate = wxPyBeginAllowThreads();
11198 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11199 wxPyEndAllowThreads(__tstate);
11200 if (PyErr_Occurred()) SWIG_fail;
11201 }
11202 resultobj = SWIG_Py_Void();
11203 {
11204 if (temp3)
11205 delete arg3;
11206 }
11207 return resultobj;
11208 fail:
11209 {
11210 if (temp3)
11211 delete arg3;
11212 }
11213 return NULL;
11214 }
11215
11216
11217 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11218 PyObject *resultobj = 0;
11219 wxGrid *arg1 = (wxGrid *) 0 ;
11220 wxDC *arg2 = 0 ;
11221 wxArrayString *arg3 = 0 ;
11222 long *arg4 = (long *) 0 ;
11223 long *arg5 = (long *) 0 ;
11224 void *argp1 = 0 ;
11225 int res1 = 0 ;
11226 void *argp2 = 0 ;
11227 int res2 = 0 ;
11228 bool temp3 = false ;
11229 long temp4 ;
11230 int res4 = SWIG_TMPOBJ ;
11231 long temp5 ;
11232 int res5 = SWIG_TMPOBJ ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 char * kwnames[] = {
11237 (char *) "self",(char *) "dc",(char *) "lines", NULL
11238 };
11239
11240 arg4 = &temp4;
11241 arg5 = &temp5;
11242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11244 if (!SWIG_IsOK(res1)) {
11245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11246 }
11247 arg1 = reinterpret_cast< wxGrid * >(argp1);
11248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11249 if (!SWIG_IsOK(res2)) {
11250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11251 }
11252 if (!argp2) {
11253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11254 }
11255 arg2 = reinterpret_cast< wxDC * >(argp2);
11256 {
11257 if (! PySequence_Check(obj2)) {
11258 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11259 SWIG_fail;
11260 }
11261 arg3 = new wxArrayString;
11262 temp3 = true;
11263 int i, len=PySequence_Length(obj2);
11264 for (i=0; i<len; i++) {
11265 PyObject* item = PySequence_GetItem(obj2, i);
11266 wxString* s = wxString_in_helper(item);
11267 if (PyErr_Occurred()) SWIG_fail;
11268 arg3->Add(*s);
11269 delete s;
11270 Py_DECREF(item);
11271 }
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 resultobj = SWIG_Py_Void();
11280 if (SWIG_IsTmpObj(res4)) {
11281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11282 } else {
11283 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11285 }
11286 if (SWIG_IsTmpObj(res5)) {
11287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11288 } else {
11289 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11291 }
11292 {
11293 if (temp3) delete arg3;
11294 }
11295 return resultobj;
11296 fail:
11297 {
11298 if (temp3) delete arg3;
11299 }
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 PyObject *resultobj = 0;
11306 wxGrid *arg1 = (wxGrid *) 0 ;
11307 void *argp1 = 0 ;
11308 int res1 = 0 ;
11309 PyObject *swig_obj[1] ;
11310
11311 if (!args) SWIG_fail;
11312 swig_obj[0] = args;
11313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11314 if (!SWIG_IsOK(res1)) {
11315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11316 }
11317 arg1 = reinterpret_cast< wxGrid * >(argp1);
11318 {
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 (arg1)->BeginBatch();
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_Py_Void();
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332 PyObject *resultobj = 0;
11333 wxGrid *arg1 = (wxGrid *) 0 ;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 PyObject *swig_obj[1] ;
11337
11338 if (!args) SWIG_fail;
11339 swig_obj[0] = args;
11340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11341 if (!SWIG_IsOK(res1)) {
11342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11343 }
11344 arg1 = reinterpret_cast< wxGrid * >(argp1);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 (arg1)->EndBatch();
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 resultobj = SWIG_Py_Void();
11352 return resultobj;
11353 fail:
11354 return NULL;
11355 }
11356
11357
11358 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11359 PyObject *resultobj = 0;
11360 wxGrid *arg1 = (wxGrid *) 0 ;
11361 int result;
11362 void *argp1 = 0 ;
11363 int res1 = 0 ;
11364 PyObject *swig_obj[1] ;
11365
11366 if (!args) SWIG_fail;
11367 swig_obj[0] = args;
11368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11369 if (!SWIG_IsOK(res1)) {
11370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11371 }
11372 arg1 = reinterpret_cast< wxGrid * >(argp1);
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (int)(arg1)->GetBatchCount();
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = SWIG_From_int(static_cast< int >(result));
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 wxGrid *arg1 = (wxGrid *) 0 ;
11389 void *argp1 = 0 ;
11390 int res1 = 0 ;
11391 PyObject *swig_obj[1] ;
11392
11393 if (!args) SWIG_fail;
11394 swig_obj[0] = args;
11395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11396 if (!SWIG_IsOK(res1)) {
11397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11398 }
11399 arg1 = reinterpret_cast< wxGrid * >(argp1);
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 (arg1)->ForceRefresh();
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 resultobj = SWIG_Py_Void();
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11414 PyObject *resultobj = 0;
11415 wxGrid *arg1 = (wxGrid *) 0 ;
11416 bool result;
11417 void *argp1 = 0 ;
11418 int res1 = 0 ;
11419 PyObject *swig_obj[1] ;
11420
11421 if (!args) SWIG_fail;
11422 swig_obj[0] = args;
11423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11426 }
11427 arg1 = reinterpret_cast< wxGrid * >(argp1);
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 result = (bool)(arg1)->IsEditable();
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11436 }
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11444 PyObject *resultobj = 0;
11445 wxGrid *arg1 = (wxGrid *) 0 ;
11446 bool arg2 ;
11447 void *argp1 = 0 ;
11448 int res1 = 0 ;
11449 bool val2 ;
11450 int ecode2 = 0 ;
11451 PyObject * obj0 = 0 ;
11452 PyObject * obj1 = 0 ;
11453 char * kwnames[] = {
11454 (char *) "self",(char *) "edit", NULL
11455 };
11456
11457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11459 if (!SWIG_IsOK(res1)) {
11460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11461 }
11462 arg1 = reinterpret_cast< wxGrid * >(argp1);
11463 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11464 if (!SWIG_IsOK(ecode2)) {
11465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11466 }
11467 arg2 = static_cast< bool >(val2);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 (arg1)->EnableEditing(arg2);
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_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj = 0;
11483 wxGrid *arg1 = (wxGrid *) 0 ;
11484 bool arg2 = (bool) true ;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 bool val2 ;
11488 int ecode2 = 0 ;
11489 PyObject * obj0 = 0 ;
11490 PyObject * obj1 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "self",(char *) "enable", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11497 if (!SWIG_IsOK(res1)) {
11498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11499 }
11500 arg1 = reinterpret_cast< wxGrid * >(argp1);
11501 if (obj1) {
11502 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11503 if (!SWIG_IsOK(ecode2)) {
11504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11505 }
11506 arg2 = static_cast< bool >(val2);
11507 }
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 (arg1)->EnableCellEditControl(arg2);
11511 wxPyEndAllowThreads(__tstate);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_Py_Void();
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11522 PyObject *resultobj = 0;
11523 wxGrid *arg1 = (wxGrid *) 0 ;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 PyObject *swig_obj[1] ;
11527
11528 if (!args) SWIG_fail;
11529 swig_obj[0] = args;
11530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11533 }
11534 arg1 = reinterpret_cast< wxGrid * >(argp1);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 (arg1)->DisableCellEditControl();
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 resultobj = SWIG_Py_Void();
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11549 PyObject *resultobj = 0;
11550 wxGrid *arg1 = (wxGrid *) 0 ;
11551 bool result;
11552 void *argp1 = 0 ;
11553 int res1 = 0 ;
11554 PyObject *swig_obj[1] ;
11555
11556 if (!args) SWIG_fail;
11557 swig_obj[0] = args;
11558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11559 if (!SWIG_IsOK(res1)) {
11560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11561 }
11562 arg1 = reinterpret_cast< wxGrid * >(argp1);
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 {
11570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11571 }
11572 return resultobj;
11573 fail:
11574 return NULL;
11575 }
11576
11577
11578 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11579 PyObject *resultobj = 0;
11580 wxGrid *arg1 = (wxGrid *) 0 ;
11581 bool result;
11582 void *argp1 = 0 ;
11583 int res1 = 0 ;
11584 PyObject *swig_obj[1] ;
11585
11586 if (!args) SWIG_fail;
11587 swig_obj[0] = args;
11588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11591 }
11592 arg1 = reinterpret_cast< wxGrid * >(argp1);
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 {
11600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11601 }
11602 return resultobj;
11603 fail:
11604 return NULL;
11605 }
11606
11607
11608 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11609 PyObject *resultobj = 0;
11610 wxGrid *arg1 = (wxGrid *) 0 ;
11611 bool result;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 PyObject *swig_obj[1] ;
11615
11616 if (!args) SWIG_fail;
11617 swig_obj[0] = args;
11618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11619 if (!SWIG_IsOK(res1)) {
11620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11621 }
11622 arg1 = reinterpret_cast< wxGrid * >(argp1);
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 {
11630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11631 }
11632 return resultobj;
11633 fail:
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxGrid *arg1 = (wxGrid *) 0 ;
11641 bool result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11651 }
11652 arg1 = reinterpret_cast< wxGrid * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *resultobj = 0;
11670 wxGrid *arg1 = (wxGrid *) 0 ;
11671 void *argp1 = 0 ;
11672 int res1 = 0 ;
11673 PyObject *swig_obj[1] ;
11674
11675 if (!args) SWIG_fail;
11676 swig_obj[0] = args;
11677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11680 }
11681 arg1 = reinterpret_cast< wxGrid * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 (arg1)->ShowCellEditControl();
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_Py_Void();
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 PyObject *resultobj = 0;
11697 wxGrid *arg1 = (wxGrid *) 0 ;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11707 }
11708 arg1 = reinterpret_cast< wxGrid * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->HideCellEditControl();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxGrid *arg1 = (wxGrid *) 0 ;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11734 }
11735 arg1 = reinterpret_cast< wxGrid * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 (arg1)->SaveEditControlValue();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj = 0;
11751 wxGrid *arg1 = (wxGrid *) 0 ;
11752 int arg2 ;
11753 int arg3 ;
11754 wxGridCellCoords result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 int val2 ;
11758 int ecode2 = 0 ;
11759 int val3 ;
11760 int ecode3 = 0 ;
11761 PyObject * obj0 = 0 ;
11762 PyObject * obj1 = 0 ;
11763 PyObject * obj2 = 0 ;
11764 char * kwnames[] = {
11765 (char *) "self",(char *) "x",(char *) "y", NULL
11766 };
11767
11768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11770 if (!SWIG_IsOK(res1)) {
11771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11772 }
11773 arg1 = reinterpret_cast< wxGrid * >(argp1);
11774 ecode2 = SWIG_AsVal_int(obj1, &val2);
11775 if (!SWIG_IsOK(ecode2)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11777 }
11778 arg2 = static_cast< int >(val2);
11779 ecode3 = SWIG_AsVal_int(obj2, &val3);
11780 if (!SWIG_IsOK(ecode3)) {
11781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11782 }
11783 arg3 = static_cast< int >(val3);
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = wxGrid_XYToCell(arg1,arg2,arg3);
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11791 return resultobj;
11792 fail:
11793 return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11798 PyObject *resultobj = 0;
11799 wxGrid *arg1 = (wxGrid *) 0 ;
11800 int arg2 ;
11801 int result;
11802 void *argp1 = 0 ;
11803 int res1 = 0 ;
11804 int val2 ;
11805 int ecode2 = 0 ;
11806 PyObject * obj0 = 0 ;
11807 PyObject * obj1 = 0 ;
11808 char * kwnames[] = {
11809 (char *) "self",(char *) "y", NULL
11810 };
11811
11812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11814 if (!SWIG_IsOK(res1)) {
11815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11816 }
11817 arg1 = reinterpret_cast< wxGrid * >(argp1);
11818 ecode2 = SWIG_AsVal_int(obj1, &val2);
11819 if (!SWIG_IsOK(ecode2)) {
11820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11821 }
11822 arg2 = static_cast< int >(val2);
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (int)(arg1)->YToRow(arg2);
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_From_int(static_cast< int >(result));
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11837 PyObject *resultobj = 0;
11838 wxGrid *arg1 = (wxGrid *) 0 ;
11839 int arg2 ;
11840 bool arg3 = (bool) false ;
11841 int result;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844 int val2 ;
11845 int ecode2 = 0 ;
11846 bool val3 ;
11847 int ecode3 = 0 ;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 PyObject * obj2 = 0 ;
11851 char * kwnames[] = {
11852 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11853 };
11854
11855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11859 }
11860 arg1 = reinterpret_cast< wxGrid * >(argp1);
11861 ecode2 = SWIG_AsVal_int(obj1, &val2);
11862 if (!SWIG_IsOK(ecode2)) {
11863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11864 }
11865 arg2 = static_cast< int >(val2);
11866 if (obj2) {
11867 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11868 if (!SWIG_IsOK(ecode3)) {
11869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11870 }
11871 arg3 = static_cast< bool >(val3);
11872 }
11873 {
11874 PyThreadState* __tstate = wxPyBeginAllowThreads();
11875 result = (int)(arg1)->XToCol(arg2,arg3);
11876 wxPyEndAllowThreads(__tstate);
11877 if (PyErr_Occurred()) SWIG_fail;
11878 }
11879 resultobj = SWIG_From_int(static_cast< int >(result));
11880 return resultobj;
11881 fail:
11882 return NULL;
11883 }
11884
11885
11886 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11887 PyObject *resultobj = 0;
11888 wxGrid *arg1 = (wxGrid *) 0 ;
11889 int arg2 ;
11890 int result;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 int val2 ;
11894 int ecode2 = 0 ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 char * kwnames[] = {
11898 (char *) "self",(char *) "y", NULL
11899 };
11900
11901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11905 }
11906 arg1 = reinterpret_cast< wxGrid * >(argp1);
11907 ecode2 = SWIG_AsVal_int(obj1, &val2);
11908 if (!SWIG_IsOK(ecode2)) {
11909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11910 }
11911 arg2 = static_cast< int >(val2);
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (int)(arg1)->YToEdgeOfRow(arg2);
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 resultobj = SWIG_From_int(static_cast< int >(result));
11919 return resultobj;
11920 fail:
11921 return NULL;
11922 }
11923
11924
11925 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11926 PyObject *resultobj = 0;
11927 wxGrid *arg1 = (wxGrid *) 0 ;
11928 int arg2 ;
11929 int result;
11930 void *argp1 = 0 ;
11931 int res1 = 0 ;
11932 int val2 ;
11933 int ecode2 = 0 ;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "x", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11944 }
11945 arg1 = reinterpret_cast< wxGrid * >(argp1);
11946 ecode2 = SWIG_AsVal_int(obj1, &val2);
11947 if (!SWIG_IsOK(ecode2)) {
11948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
11949 }
11950 arg2 = static_cast< int >(val2);
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (int)(arg1)->XToEdgeOfCol(arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 resultobj = SWIG_From_int(static_cast< int >(result));
11958 return resultobj;
11959 fail:
11960 return NULL;
11961 }
11962
11963
11964 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11965 PyObject *resultobj = 0;
11966 wxGrid *arg1 = (wxGrid *) 0 ;
11967 int arg2 ;
11968 int arg3 ;
11969 wxRect result;
11970 void *argp1 = 0 ;
11971 int res1 = 0 ;
11972 int val2 ;
11973 int ecode2 = 0 ;
11974 int val3 ;
11975 int ecode3 = 0 ;
11976 PyObject * obj0 = 0 ;
11977 PyObject * obj1 = 0 ;
11978 PyObject * obj2 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "row",(char *) "col", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
11987 }
11988 arg1 = reinterpret_cast< wxGrid * >(argp1);
11989 ecode2 = SWIG_AsVal_int(obj1, &val2);
11990 if (!SWIG_IsOK(ecode2)) {
11991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
11992 }
11993 arg2 = static_cast< int >(val2);
11994 ecode3 = SWIG_AsVal_int(obj2, &val3);
11995 if (!SWIG_IsOK(ecode3)) {
11996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
11997 }
11998 arg3 = static_cast< int >(val3);
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (arg1)->CellToRect(arg2,arg3);
12002 wxPyEndAllowThreads(__tstate);
12003 if (PyErr_Occurred()) SWIG_fail;
12004 }
12005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12013 PyObject *resultobj = 0;
12014 wxGrid *arg1 = (wxGrid *) 0 ;
12015 int result;
12016 void *argp1 = 0 ;
12017 int res1 = 0 ;
12018 PyObject *swig_obj[1] ;
12019
12020 if (!args) SWIG_fail;
12021 swig_obj[0] = args;
12022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12023 if (!SWIG_IsOK(res1)) {
12024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12025 }
12026 arg1 = reinterpret_cast< wxGrid * >(argp1);
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (int)(arg1)->GetGridCursorRow();
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 resultobj = SWIG_From_int(static_cast< int >(result));
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12041 PyObject *resultobj = 0;
12042 wxGrid *arg1 = (wxGrid *) 0 ;
12043 int result;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject *swig_obj[1] ;
12047
12048 if (!args) SWIG_fail;
12049 swig_obj[0] = args;
12050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12051 if (!SWIG_IsOK(res1)) {
12052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12053 }
12054 arg1 = reinterpret_cast< wxGrid * >(argp1);
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (int)(arg1)->GetGridCursorCol();
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_From_int(static_cast< int >(result));
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12069 PyObject *resultobj = 0;
12070 wxGrid *arg1 = (wxGrid *) 0 ;
12071 int arg2 ;
12072 int arg3 ;
12073 bool arg4 = (bool) true ;
12074 bool result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 int val2 ;
12078 int ecode2 = 0 ;
12079 int val3 ;
12080 int ecode3 = 0 ;
12081 bool val4 ;
12082 int ecode4 = 0 ;
12083 PyObject * obj0 = 0 ;
12084 PyObject * obj1 = 0 ;
12085 PyObject * obj2 = 0 ;
12086 PyObject * obj3 = 0 ;
12087 char * kwnames[] = {
12088 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12089 };
12090
12091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12093 if (!SWIG_IsOK(res1)) {
12094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12095 }
12096 arg1 = reinterpret_cast< wxGrid * >(argp1);
12097 ecode2 = SWIG_AsVal_int(obj1, &val2);
12098 if (!SWIG_IsOK(ecode2)) {
12099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12100 }
12101 arg2 = static_cast< int >(val2);
12102 ecode3 = SWIG_AsVal_int(obj2, &val3);
12103 if (!SWIG_IsOK(ecode3)) {
12104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12105 }
12106 arg3 = static_cast< int >(val3);
12107 if (obj3) {
12108 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12109 if (!SWIG_IsOK(ecode4)) {
12110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12111 }
12112 arg4 = static_cast< bool >(val4);
12113 }
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 {
12121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12122 }
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj = 0;
12131 wxGrid *arg1 = (wxGrid *) 0 ;
12132 int arg2 ;
12133 int arg3 ;
12134 void *argp1 = 0 ;
12135 int res1 = 0 ;
12136 int val2 ;
12137 int ecode2 = 0 ;
12138 int val3 ;
12139 int ecode3 = 0 ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 PyObject * obj2 = 0 ;
12143 char * kwnames[] = {
12144 (char *) "self",(char *) "row",(char *) "col", NULL
12145 };
12146
12147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12149 if (!SWIG_IsOK(res1)) {
12150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12151 }
12152 arg1 = reinterpret_cast< wxGrid * >(argp1);
12153 ecode2 = SWIG_AsVal_int(obj1, &val2);
12154 if (!SWIG_IsOK(ecode2)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12156 }
12157 arg2 = static_cast< int >(val2);
12158 ecode3 = SWIG_AsVal_int(obj2, &val3);
12159 if (!SWIG_IsOK(ecode3)) {
12160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12161 }
12162 arg3 = static_cast< int >(val3);
12163 {
12164 PyThreadState* __tstate = wxPyBeginAllowThreads();
12165 (arg1)->MakeCellVisible(arg2,arg3);
12166 wxPyEndAllowThreads(__tstate);
12167 if (PyErr_Occurred()) SWIG_fail;
12168 }
12169 resultobj = SWIG_Py_Void();
12170 return resultobj;
12171 fail:
12172 return NULL;
12173 }
12174
12175
12176 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12177 PyObject *resultobj = 0;
12178 wxGrid *arg1 = (wxGrid *) 0 ;
12179 int arg2 ;
12180 int arg3 ;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 int val2 ;
12184 int ecode2 = 0 ;
12185 int val3 ;
12186 int ecode3 = 0 ;
12187 PyObject * obj0 = 0 ;
12188 PyObject * obj1 = 0 ;
12189 PyObject * obj2 = 0 ;
12190 char * kwnames[] = {
12191 (char *) "self",(char *) "row",(char *) "col", NULL
12192 };
12193
12194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12196 if (!SWIG_IsOK(res1)) {
12197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12198 }
12199 arg1 = reinterpret_cast< wxGrid * >(argp1);
12200 ecode2 = SWIG_AsVal_int(obj1, &val2);
12201 if (!SWIG_IsOK(ecode2)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12203 }
12204 arg2 = static_cast< int >(val2);
12205 ecode3 = SWIG_AsVal_int(obj2, &val3);
12206 if (!SWIG_IsOK(ecode3)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12208 }
12209 arg3 = static_cast< int >(val3);
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 (arg1)->SetGridCursor(arg2,arg3);
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = SWIG_Py_Void();
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj = 0;
12225 wxGrid *arg1 = (wxGrid *) 0 ;
12226 bool arg2 ;
12227 bool result;
12228 void *argp1 = 0 ;
12229 int res1 = 0 ;
12230 bool val2 ;
12231 int ecode2 = 0 ;
12232 PyObject * obj0 = 0 ;
12233 PyObject * obj1 = 0 ;
12234 char * kwnames[] = {
12235 (char *) "self",(char *) "expandSelection", NULL
12236 };
12237
12238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12240 if (!SWIG_IsOK(res1)) {
12241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12242 }
12243 arg1 = reinterpret_cast< wxGrid * >(argp1);
12244 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12245 if (!SWIG_IsOK(ecode2)) {
12246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12247 }
12248 arg2 = static_cast< bool >(val2);
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (bool)(arg1)->MoveCursorUp(arg2);
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = 0;
12266 wxGrid *arg1 = (wxGrid *) 0 ;
12267 bool arg2 ;
12268 bool result;
12269 void *argp1 = 0 ;
12270 int res1 = 0 ;
12271 bool val2 ;
12272 int ecode2 = 0 ;
12273 PyObject * obj0 = 0 ;
12274 PyObject * obj1 = 0 ;
12275 char * kwnames[] = {
12276 (char *) "self",(char *) "expandSelection", NULL
12277 };
12278
12279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12283 }
12284 arg1 = reinterpret_cast< wxGrid * >(argp1);
12285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12286 if (!SWIG_IsOK(ecode2)) {
12287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12288 }
12289 arg2 = static_cast< bool >(val2);
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 result = (bool)(arg1)->MoveCursorDown(arg2);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 {
12297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12298 }
12299 return resultobj;
12300 fail:
12301 return NULL;
12302 }
12303
12304
12305 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj = 0;
12307 wxGrid *arg1 = (wxGrid *) 0 ;
12308 bool arg2 ;
12309 bool result;
12310 void *argp1 = 0 ;
12311 int res1 = 0 ;
12312 bool val2 ;
12313 int ecode2 = 0 ;
12314 PyObject * obj0 = 0 ;
12315 PyObject * obj1 = 0 ;
12316 char * kwnames[] = {
12317 (char *) "self",(char *) "expandSelection", NULL
12318 };
12319
12320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12324 }
12325 arg1 = reinterpret_cast< wxGrid * >(argp1);
12326 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12327 if (!SWIG_IsOK(ecode2)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12329 }
12330 arg2 = static_cast< bool >(val2);
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 result = (bool)(arg1)->MoveCursorLeft(arg2);
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 {
12338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12339 }
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj = 0;
12348 wxGrid *arg1 = (wxGrid *) 0 ;
12349 bool arg2 ;
12350 bool result;
12351 void *argp1 = 0 ;
12352 int res1 = 0 ;
12353 bool val2 ;
12354 int ecode2 = 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char * kwnames[] = {
12358 (char *) "self",(char *) "expandSelection", NULL
12359 };
12360
12361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12363 if (!SWIG_IsOK(res1)) {
12364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12365 }
12366 arg1 = reinterpret_cast< wxGrid * >(argp1);
12367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12368 if (!SWIG_IsOK(ecode2)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12370 }
12371 arg2 = static_cast< bool >(val2);
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (bool)(arg1)->MoveCursorRight(arg2);
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 {
12379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12380 }
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12388 PyObject *resultobj = 0;
12389 wxGrid *arg1 = (wxGrid *) 0 ;
12390 bool result;
12391 void *argp1 = 0 ;
12392 int res1 = 0 ;
12393 PyObject *swig_obj[1] ;
12394
12395 if (!args) SWIG_fail;
12396 swig_obj[0] = args;
12397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12398 if (!SWIG_IsOK(res1)) {
12399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12400 }
12401 arg1 = reinterpret_cast< wxGrid * >(argp1);
12402 {
12403 PyThreadState* __tstate = wxPyBeginAllowThreads();
12404 result = (bool)(arg1)->MovePageDown();
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 {
12409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12410 }
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12418 PyObject *resultobj = 0;
12419 wxGrid *arg1 = (wxGrid *) 0 ;
12420 bool result;
12421 void *argp1 = 0 ;
12422 int res1 = 0 ;
12423 PyObject *swig_obj[1] ;
12424
12425 if (!args) SWIG_fail;
12426 swig_obj[0] = args;
12427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12428 if (!SWIG_IsOK(res1)) {
12429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12430 }
12431 arg1 = reinterpret_cast< wxGrid * >(argp1);
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 result = (bool)(arg1)->MovePageUp();
12435 wxPyEndAllowThreads(__tstate);
12436 if (PyErr_Occurred()) SWIG_fail;
12437 }
12438 {
12439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12440 }
12441 return resultobj;
12442 fail:
12443 return NULL;
12444 }
12445
12446
12447 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12448 PyObject *resultobj = 0;
12449 wxGrid *arg1 = (wxGrid *) 0 ;
12450 bool arg2 ;
12451 bool result;
12452 void *argp1 = 0 ;
12453 int res1 = 0 ;
12454 bool val2 ;
12455 int ecode2 = 0 ;
12456 PyObject * obj0 = 0 ;
12457 PyObject * obj1 = 0 ;
12458 char * kwnames[] = {
12459 (char *) "self",(char *) "expandSelection", NULL
12460 };
12461
12462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12464 if (!SWIG_IsOK(res1)) {
12465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12466 }
12467 arg1 = reinterpret_cast< wxGrid * >(argp1);
12468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12469 if (!SWIG_IsOK(ecode2)) {
12470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12471 }
12472 arg2 = static_cast< bool >(val2);
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj = 0;
12490 wxGrid *arg1 = (wxGrid *) 0 ;
12491 bool arg2 ;
12492 bool result;
12493 void *argp1 = 0 ;
12494 int res1 = 0 ;
12495 bool val2 ;
12496 int ecode2 = 0 ;
12497 PyObject * obj0 = 0 ;
12498 PyObject * obj1 = 0 ;
12499 char * kwnames[] = {
12500 (char *) "self",(char *) "expandSelection", NULL
12501 };
12502
12503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12505 if (!SWIG_IsOK(res1)) {
12506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12507 }
12508 arg1 = reinterpret_cast< wxGrid * >(argp1);
12509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12510 if (!SWIG_IsOK(ecode2)) {
12511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12512 }
12513 arg2 = static_cast< bool >(val2);
12514 {
12515 PyThreadState* __tstate = wxPyBeginAllowThreads();
12516 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12517 wxPyEndAllowThreads(__tstate);
12518 if (PyErr_Occurred()) SWIG_fail;
12519 }
12520 {
12521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12522 }
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxGrid *arg1 = (wxGrid *) 0 ;
12532 bool arg2 ;
12533 bool result;
12534 void *argp1 = 0 ;
12535 int res1 = 0 ;
12536 bool val2 ;
12537 int ecode2 = 0 ;
12538 PyObject * obj0 = 0 ;
12539 PyObject * obj1 = 0 ;
12540 char * kwnames[] = {
12541 (char *) "self",(char *) "expandSelection", NULL
12542 };
12543
12544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12546 if (!SWIG_IsOK(res1)) {
12547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12548 }
12549 arg1 = reinterpret_cast< wxGrid * >(argp1);
12550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12551 if (!SWIG_IsOK(ecode2)) {
12552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12553 }
12554 arg2 = static_cast< bool >(val2);
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12558 wxPyEndAllowThreads(__tstate);
12559 if (PyErr_Occurred()) SWIG_fail;
12560 }
12561 {
12562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12563 }
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12571 PyObject *resultobj = 0;
12572 wxGrid *arg1 = (wxGrid *) 0 ;
12573 bool arg2 ;
12574 bool result;
12575 void *argp1 = 0 ;
12576 int res1 = 0 ;
12577 bool val2 ;
12578 int ecode2 = 0 ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "self",(char *) "expandSelection", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12589 }
12590 arg1 = reinterpret_cast< wxGrid * >(argp1);
12591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12592 if (!SWIG_IsOK(ecode2)) {
12593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12594 }
12595 arg2 = static_cast< bool >(val2);
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 {
12603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12604 }
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612 PyObject *resultobj = 0;
12613 wxGrid *arg1 = (wxGrid *) 0 ;
12614 int result;
12615 void *argp1 = 0 ;
12616 int res1 = 0 ;
12617 PyObject *swig_obj[1] ;
12618
12619 if (!args) SWIG_fail;
12620 swig_obj[0] = args;
12621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12622 if (!SWIG_IsOK(res1)) {
12623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12624 }
12625 arg1 = reinterpret_cast< wxGrid * >(argp1);
12626 {
12627 PyThreadState* __tstate = wxPyBeginAllowThreads();
12628 result = (int)(arg1)->GetDefaultRowLabelSize();
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = SWIG_From_int(static_cast< int >(result));
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12640 PyObject *resultobj = 0;
12641 wxGrid *arg1 = (wxGrid *) 0 ;
12642 int result;
12643 void *argp1 = 0 ;
12644 int res1 = 0 ;
12645 PyObject *swig_obj[1] ;
12646
12647 if (!args) SWIG_fail;
12648 swig_obj[0] = args;
12649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12650 if (!SWIG_IsOK(res1)) {
12651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12652 }
12653 arg1 = reinterpret_cast< wxGrid * >(argp1);
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 result = (int)(arg1)->GetRowLabelSize();
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 resultobj = SWIG_From_int(static_cast< int >(result));
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12668 PyObject *resultobj = 0;
12669 wxGrid *arg1 = (wxGrid *) 0 ;
12670 int result;
12671 void *argp1 = 0 ;
12672 int res1 = 0 ;
12673 PyObject *swig_obj[1] ;
12674
12675 if (!args) SWIG_fail;
12676 swig_obj[0] = args;
12677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12678 if (!SWIG_IsOK(res1)) {
12679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12680 }
12681 arg1 = reinterpret_cast< wxGrid * >(argp1);
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (int)(arg1)->GetDefaultColLabelSize();
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 resultobj = SWIG_From_int(static_cast< int >(result));
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12696 PyObject *resultobj = 0;
12697 wxGrid *arg1 = (wxGrid *) 0 ;
12698 int result;
12699 void *argp1 = 0 ;
12700 int res1 = 0 ;
12701 PyObject *swig_obj[1] ;
12702
12703 if (!args) SWIG_fail;
12704 swig_obj[0] = args;
12705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12706 if (!SWIG_IsOK(res1)) {
12707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12708 }
12709 arg1 = reinterpret_cast< wxGrid * >(argp1);
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 result = (int)(arg1)->GetColLabelSize();
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 resultobj = SWIG_From_int(static_cast< int >(result));
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxGrid *arg1 = (wxGrid *) 0 ;
12726 wxColour result;
12727 void *argp1 = 0 ;
12728 int res1 = 0 ;
12729 PyObject *swig_obj[1] ;
12730
12731 if (!args) SWIG_fail;
12732 swig_obj[0] = args;
12733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12736 }
12737 arg1 = reinterpret_cast< wxGrid * >(argp1);
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (arg1)->GetLabelBackgroundColour();
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxGrid *arg1 = (wxGrid *) 0 ;
12754 wxColour result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12764 }
12765 arg1 = reinterpret_cast< wxGrid * >(argp1);
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (arg1)->GetLabelTextColour();
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12780 PyObject *resultobj = 0;
12781 wxGrid *arg1 = (wxGrid *) 0 ;
12782 wxFont result;
12783 void *argp1 = 0 ;
12784 int res1 = 0 ;
12785 PyObject *swig_obj[1] ;
12786
12787 if (!args) SWIG_fail;
12788 swig_obj[0] = args;
12789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12792 }
12793 arg1 = reinterpret_cast< wxGrid * >(argp1);
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 result = (arg1)->GetLabelFont();
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12808 PyObject *resultobj = 0;
12809 wxGrid *arg1 = (wxGrid *) 0 ;
12810 int *arg2 = (int *) 0 ;
12811 int *arg3 = (int *) 0 ;
12812 void *argp1 = 0 ;
12813 int res1 = 0 ;
12814 int temp2 ;
12815 int res2 = SWIG_TMPOBJ ;
12816 int temp3 ;
12817 int res3 = SWIG_TMPOBJ ;
12818 PyObject *swig_obj[1] ;
12819
12820 arg2 = &temp2;
12821 arg3 = &temp3;
12822 if (!args) SWIG_fail;
12823 swig_obj[0] = args;
12824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12825 if (!SWIG_IsOK(res1)) {
12826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12827 }
12828 arg1 = reinterpret_cast< wxGrid * >(argp1);
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 (arg1)->GetRowLabelAlignment(arg2,arg3);
12832 wxPyEndAllowThreads(__tstate);
12833 if (PyErr_Occurred()) SWIG_fail;
12834 }
12835 resultobj = SWIG_Py_Void();
12836 if (SWIG_IsTmpObj(res2)) {
12837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12838 } else {
12839 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12841 }
12842 if (SWIG_IsTmpObj(res3)) {
12843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12844 } else {
12845 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12847 }
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxGrid *arg1 = (wxGrid *) 0 ;
12857 int *arg2 = (int *) 0 ;
12858 int *arg3 = (int *) 0 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 int temp2 ;
12862 int res2 = SWIG_TMPOBJ ;
12863 int temp3 ;
12864 int res3 = SWIG_TMPOBJ ;
12865 PyObject *swig_obj[1] ;
12866
12867 arg2 = &temp2;
12868 arg3 = &temp3;
12869 if (!args) SWIG_fail;
12870 swig_obj[0] = args;
12871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12872 if (!SWIG_IsOK(res1)) {
12873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12874 }
12875 arg1 = reinterpret_cast< wxGrid * >(argp1);
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 (arg1)->GetColLabelAlignment(arg2,arg3);
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 resultobj = SWIG_Py_Void();
12883 if (SWIG_IsTmpObj(res2)) {
12884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12885 } else {
12886 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12888 }
12889 if (SWIG_IsTmpObj(res3)) {
12890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12891 } else {
12892 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12894 }
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902 PyObject *resultobj = 0;
12903 wxGrid *arg1 = (wxGrid *) 0 ;
12904 int result;
12905 void *argp1 = 0 ;
12906 int res1 = 0 ;
12907 PyObject *swig_obj[1] ;
12908
12909 if (!args) SWIG_fail;
12910 swig_obj[0] = args;
12911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12912 if (!SWIG_IsOK(res1)) {
12913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12914 }
12915 arg1 = reinterpret_cast< wxGrid * >(argp1);
12916 {
12917 PyThreadState* __tstate = wxPyBeginAllowThreads();
12918 result = (int)(arg1)->GetColLabelTextOrientation();
12919 wxPyEndAllowThreads(__tstate);
12920 if (PyErr_Occurred()) SWIG_fail;
12921 }
12922 resultobj = SWIG_From_int(static_cast< int >(result));
12923 return resultobj;
12924 fail:
12925 return NULL;
12926 }
12927
12928
12929 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12930 PyObject *resultobj = 0;
12931 wxGrid *arg1 = (wxGrid *) 0 ;
12932 int arg2 ;
12933 wxString result;
12934 void *argp1 = 0 ;
12935 int res1 = 0 ;
12936 int val2 ;
12937 int ecode2 = 0 ;
12938 PyObject * obj0 = 0 ;
12939 PyObject * obj1 = 0 ;
12940 char * kwnames[] = {
12941 (char *) "self",(char *) "row", NULL
12942 };
12943
12944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
12945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12946 if (!SWIG_IsOK(res1)) {
12947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12948 }
12949 arg1 = reinterpret_cast< wxGrid * >(argp1);
12950 ecode2 = SWIG_AsVal_int(obj1, &val2);
12951 if (!SWIG_IsOK(ecode2)) {
12952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
12953 }
12954 arg2 = static_cast< int >(val2);
12955 {
12956 PyThreadState* __tstate = wxPyBeginAllowThreads();
12957 result = (arg1)->GetRowLabelValue(arg2);
12958 wxPyEndAllowThreads(__tstate);
12959 if (PyErr_Occurred()) SWIG_fail;
12960 }
12961 {
12962 #if wxUSE_UNICODE
12963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12964 #else
12965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12966 #endif
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj = 0;
12976 wxGrid *arg1 = (wxGrid *) 0 ;
12977 int arg2 ;
12978 wxString result;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 int val2 ;
12982 int ecode2 = 0 ;
12983 PyObject * obj0 = 0 ;
12984 PyObject * obj1 = 0 ;
12985 char * kwnames[] = {
12986 (char *) "self",(char *) "col", NULL
12987 };
12988
12989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
12990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12993 }
12994 arg1 = reinterpret_cast< wxGrid * >(argp1);
12995 ecode2 = SWIG_AsVal_int(obj1, &val2);
12996 if (!SWIG_IsOK(ecode2)) {
12997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
12998 }
12999 arg2 = static_cast< int >(val2);
13000 {
13001 PyThreadState* __tstate = wxPyBeginAllowThreads();
13002 result = (arg1)->GetColLabelValue(arg2);
13003 wxPyEndAllowThreads(__tstate);
13004 if (PyErr_Occurred()) SWIG_fail;
13005 }
13006 {
13007 #if wxUSE_UNICODE
13008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13009 #else
13010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13011 #endif
13012 }
13013 return resultobj;
13014 fail:
13015 return NULL;
13016 }
13017
13018
13019 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13020 PyObject *resultobj = 0;
13021 wxGrid *arg1 = (wxGrid *) 0 ;
13022 wxColour result;
13023 void *argp1 = 0 ;
13024 int res1 = 0 ;
13025 PyObject *swig_obj[1] ;
13026
13027 if (!args) SWIG_fail;
13028 swig_obj[0] = args;
13029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13030 if (!SWIG_IsOK(res1)) {
13031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13032 }
13033 arg1 = reinterpret_cast< wxGrid * >(argp1);
13034 {
13035 PyThreadState* __tstate = wxPyBeginAllowThreads();
13036 result = (arg1)->GetGridLineColour();
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13041 return resultobj;
13042 fail:
13043 return NULL;
13044 }
13045
13046
13047 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13048 PyObject *resultobj = 0;
13049 wxGrid *arg1 = (wxGrid *) 0 ;
13050 wxPen result;
13051 void *argp1 = 0 ;
13052 int res1 = 0 ;
13053 PyObject *swig_obj[1] ;
13054
13055 if (!args) SWIG_fail;
13056 swig_obj[0] = args;
13057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13058 if (!SWIG_IsOK(res1)) {
13059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13060 }
13061 arg1 = reinterpret_cast< wxGrid * >(argp1);
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (arg1)->GetDefaultGridLinePen();
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13069 return resultobj;
13070 fail:
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj = 0;
13077 wxGrid *arg1 = (wxGrid *) 0 ;
13078 int arg2 ;
13079 wxPen result;
13080 void *argp1 = 0 ;
13081 int res1 = 0 ;
13082 int val2 ;
13083 int ecode2 = 0 ;
13084 PyObject * obj0 = 0 ;
13085 PyObject * obj1 = 0 ;
13086 char * kwnames[] = {
13087 (char *) "self",(char *) "row", NULL
13088 };
13089
13090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13092 if (!SWIG_IsOK(res1)) {
13093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13094 }
13095 arg1 = reinterpret_cast< wxGrid * >(argp1);
13096 ecode2 = SWIG_AsVal_int(obj1, &val2);
13097 if (!SWIG_IsOK(ecode2)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13099 }
13100 arg2 = static_cast< int >(val2);
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (arg1)->GetRowGridLinePen(arg2);
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj = 0;
13116 wxGrid *arg1 = (wxGrid *) 0 ;
13117 int arg2 ;
13118 wxPen result;
13119 void *argp1 = 0 ;
13120 int res1 = 0 ;
13121 int val2 ;
13122 int ecode2 = 0 ;
13123 PyObject * obj0 = 0 ;
13124 PyObject * obj1 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "self",(char *) "col", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13131 if (!SWIG_IsOK(res1)) {
13132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13133 }
13134 arg1 = reinterpret_cast< wxGrid * >(argp1);
13135 ecode2 = SWIG_AsVal_int(obj1, &val2);
13136 if (!SWIG_IsOK(ecode2)) {
13137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13138 }
13139 arg2 = static_cast< int >(val2);
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (arg1)->GetColGridLinePen(arg2);
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13154 PyObject *resultobj = 0;
13155 wxGrid *arg1 = (wxGrid *) 0 ;
13156 wxColour result;
13157 void *argp1 = 0 ;
13158 int res1 = 0 ;
13159 PyObject *swig_obj[1] ;
13160
13161 if (!args) SWIG_fail;
13162 swig_obj[0] = args;
13163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13166 }
13167 arg1 = reinterpret_cast< wxGrid * >(argp1);
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (arg1)->GetCellHighlightColour();
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13182 PyObject *resultobj = 0;
13183 wxGrid *arg1 = (wxGrid *) 0 ;
13184 int result;
13185 void *argp1 = 0 ;
13186 int res1 = 0 ;
13187 PyObject *swig_obj[1] ;
13188
13189 if (!args) SWIG_fail;
13190 swig_obj[0] = args;
13191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13192 if (!SWIG_IsOK(res1)) {
13193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13194 }
13195 arg1 = reinterpret_cast< wxGrid * >(argp1);
13196 {
13197 PyThreadState* __tstate = wxPyBeginAllowThreads();
13198 result = (int)(arg1)->GetCellHighlightPenWidth();
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 resultobj = SWIG_From_int(static_cast< int >(result));
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13210 PyObject *resultobj = 0;
13211 wxGrid *arg1 = (wxGrid *) 0 ;
13212 int result;
13213 void *argp1 = 0 ;
13214 int res1 = 0 ;
13215 PyObject *swig_obj[1] ;
13216
13217 if (!args) SWIG_fail;
13218 swig_obj[0] = args;
13219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13220 if (!SWIG_IsOK(res1)) {
13221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13222 }
13223 arg1 = reinterpret_cast< wxGrid * >(argp1);
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (int)(arg1)->GetCellHighlightROPenWidth();
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_From_int(static_cast< int >(result));
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj = 0;
13239 wxGrid *arg1 = (wxGrid *) 0 ;
13240 int arg2 ;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 int val2 ;
13244 int ecode2 = 0 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 char * kwnames[] = {
13248 (char *) "self",(char *) "width", NULL
13249 };
13250
13251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13253 if (!SWIG_IsOK(res1)) {
13254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13255 }
13256 arg1 = reinterpret_cast< wxGrid * >(argp1);
13257 ecode2 = SWIG_AsVal_int(obj1, &val2);
13258 if (!SWIG_IsOK(ecode2)) {
13259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13260 }
13261 arg2 = static_cast< int >(val2);
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 (arg1)->SetRowLabelSize(arg2);
13265 wxPyEndAllowThreads(__tstate);
13266 if (PyErr_Occurred()) SWIG_fail;
13267 }
13268 resultobj = SWIG_Py_Void();
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj = 0;
13277 wxGrid *arg1 = (wxGrid *) 0 ;
13278 int arg2 ;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 int val2 ;
13282 int ecode2 = 0 ;
13283 PyObject * obj0 = 0 ;
13284 PyObject * obj1 = 0 ;
13285 char * kwnames[] = {
13286 (char *) "self",(char *) "height", NULL
13287 };
13288
13289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13291 if (!SWIG_IsOK(res1)) {
13292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13293 }
13294 arg1 = reinterpret_cast< wxGrid * >(argp1);
13295 ecode2 = SWIG_AsVal_int(obj1, &val2);
13296 if (!SWIG_IsOK(ecode2)) {
13297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13298 }
13299 arg2 = static_cast< int >(val2);
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 (arg1)->SetColLabelSize(arg2);
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 resultobj = SWIG_Py_Void();
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = 0;
13315 wxGrid *arg1 = (wxGrid *) 0 ;
13316 wxColour *arg2 = 0 ;
13317 void *argp1 = 0 ;
13318 int res1 = 0 ;
13319 wxColour temp2 ;
13320 PyObject * obj0 = 0 ;
13321 PyObject * obj1 = 0 ;
13322 char * kwnames[] = {
13323 (char *) "self",(char *)"arg2", NULL
13324 };
13325
13326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13330 }
13331 arg1 = reinterpret_cast< wxGrid * >(argp1);
13332 {
13333 arg2 = &temp2;
13334 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13335 }
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_Py_Void();
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13350 PyObject *resultobj = 0;
13351 wxGrid *arg1 = (wxGrid *) 0 ;
13352 wxColour *arg2 = 0 ;
13353 void *argp1 = 0 ;
13354 int res1 = 0 ;
13355 wxColour temp2 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "self",(char *)"arg2", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13366 }
13367 arg1 = reinterpret_cast< wxGrid * >(argp1);
13368 {
13369 arg2 = &temp2;
13370 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_Py_Void();
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = 0;
13387 wxGrid *arg1 = (wxGrid *) 0 ;
13388 wxFont *arg2 = 0 ;
13389 void *argp1 = 0 ;
13390 int res1 = 0 ;
13391 void *argp2 = 0 ;
13392 int res2 = 0 ;
13393 PyObject * obj0 = 0 ;
13394 PyObject * obj1 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *)"arg2", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13403 }
13404 arg1 = reinterpret_cast< wxGrid * >(argp1);
13405 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13406 if (!SWIG_IsOK(res2)) {
13407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13408 }
13409 if (!argp2) {
13410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13411 }
13412 arg2 = reinterpret_cast< wxFont * >(argp2);
13413 {
13414 PyThreadState* __tstate = wxPyBeginAllowThreads();
13415 (arg1)->SetLabelFont((wxFont const &)*arg2);
13416 wxPyEndAllowThreads(__tstate);
13417 if (PyErr_Occurred()) SWIG_fail;
13418 }
13419 resultobj = SWIG_Py_Void();
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = 0;
13428 wxGrid *arg1 = (wxGrid *) 0 ;
13429 int arg2 ;
13430 int arg3 ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 int val2 ;
13434 int ecode2 = 0 ;
13435 int val3 ;
13436 int ecode3 = 0 ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 PyObject * obj2 = 0 ;
13440 char * kwnames[] = {
13441 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13442 };
13443
13444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13446 if (!SWIG_IsOK(res1)) {
13447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13448 }
13449 arg1 = reinterpret_cast< wxGrid * >(argp1);
13450 ecode2 = SWIG_AsVal_int(obj1, &val2);
13451 if (!SWIG_IsOK(ecode2)) {
13452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13453 }
13454 arg2 = static_cast< int >(val2);
13455 ecode3 = SWIG_AsVal_int(obj2, &val3);
13456 if (!SWIG_IsOK(ecode3)) {
13457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13458 }
13459 arg3 = static_cast< int >(val3);
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 (arg1)->SetRowLabelAlignment(arg2,arg3);
13463 wxPyEndAllowThreads(__tstate);
13464 if (PyErr_Occurred()) SWIG_fail;
13465 }
13466 resultobj = SWIG_Py_Void();
13467 return resultobj;
13468 fail:
13469 return NULL;
13470 }
13471
13472
13473 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13474 PyObject *resultobj = 0;
13475 wxGrid *arg1 = (wxGrid *) 0 ;
13476 int arg2 ;
13477 int arg3 ;
13478 void *argp1 = 0 ;
13479 int res1 = 0 ;
13480 int val2 ;
13481 int ecode2 = 0 ;
13482 int val3 ;
13483 int ecode3 = 0 ;
13484 PyObject * obj0 = 0 ;
13485 PyObject * obj1 = 0 ;
13486 PyObject * obj2 = 0 ;
13487 char * kwnames[] = {
13488 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13489 };
13490
13491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13493 if (!SWIG_IsOK(res1)) {
13494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13495 }
13496 arg1 = reinterpret_cast< wxGrid * >(argp1);
13497 ecode2 = SWIG_AsVal_int(obj1, &val2);
13498 if (!SWIG_IsOK(ecode2)) {
13499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13500 }
13501 arg2 = static_cast< int >(val2);
13502 ecode3 = SWIG_AsVal_int(obj2, &val3);
13503 if (!SWIG_IsOK(ecode3)) {
13504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13505 }
13506 arg3 = static_cast< int >(val3);
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 (arg1)->SetColLabelAlignment(arg2,arg3);
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 resultobj = SWIG_Py_Void();
13514 return resultobj;
13515 fail:
13516 return NULL;
13517 }
13518
13519
13520 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13521 PyObject *resultobj = 0;
13522 wxGrid *arg1 = (wxGrid *) 0 ;
13523 int arg2 ;
13524 void *argp1 = 0 ;
13525 int res1 = 0 ;
13526 int val2 ;
13527 int ecode2 = 0 ;
13528 PyObject * obj0 = 0 ;
13529 PyObject * obj1 = 0 ;
13530 char * kwnames[] = {
13531 (char *) "self",(char *) "textOrientation", NULL
13532 };
13533
13534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13536 if (!SWIG_IsOK(res1)) {
13537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13538 }
13539 arg1 = reinterpret_cast< wxGrid * >(argp1);
13540 ecode2 = SWIG_AsVal_int(obj1, &val2);
13541 if (!SWIG_IsOK(ecode2)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13543 }
13544 arg2 = static_cast< int >(val2);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 (arg1)->SetColLabelTextOrientation(arg2);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_Py_Void();
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxGrid *arg1 = (wxGrid *) 0 ;
13561 int arg2 ;
13562 wxString *arg3 = 0 ;
13563 void *argp1 = 0 ;
13564 int res1 = 0 ;
13565 int val2 ;
13566 int ecode2 = 0 ;
13567 bool temp3 = false ;
13568 PyObject * obj0 = 0 ;
13569 PyObject * obj1 = 0 ;
13570 PyObject * obj2 = 0 ;
13571 char * kwnames[] = {
13572 (char *) "self",(char *) "row",(char *)"arg3", NULL
13573 };
13574
13575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13577 if (!SWIG_IsOK(res1)) {
13578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13579 }
13580 arg1 = reinterpret_cast< wxGrid * >(argp1);
13581 ecode2 = SWIG_AsVal_int(obj1, &val2);
13582 if (!SWIG_IsOK(ecode2)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13584 }
13585 arg2 = static_cast< int >(val2);
13586 {
13587 arg3 = wxString_in_helper(obj2);
13588 if (arg3 == NULL) SWIG_fail;
13589 temp3 = true;
13590 }
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 resultobj = SWIG_Py_Void();
13598 {
13599 if (temp3)
13600 delete arg3;
13601 }
13602 return resultobj;
13603 fail:
13604 {
13605 if (temp3)
13606 delete arg3;
13607 }
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj = 0;
13614 wxGrid *arg1 = (wxGrid *) 0 ;
13615 int arg2 ;
13616 wxString *arg3 = 0 ;
13617 void *argp1 = 0 ;
13618 int res1 = 0 ;
13619 int val2 ;
13620 int ecode2 = 0 ;
13621 bool temp3 = false ;
13622 PyObject * obj0 = 0 ;
13623 PyObject * obj1 = 0 ;
13624 PyObject * obj2 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "self",(char *) "col",(char *)"arg3", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13633 }
13634 arg1 = reinterpret_cast< wxGrid * >(argp1);
13635 ecode2 = SWIG_AsVal_int(obj1, &val2);
13636 if (!SWIG_IsOK(ecode2)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13638 }
13639 arg2 = static_cast< int >(val2);
13640 {
13641 arg3 = wxString_in_helper(obj2);
13642 if (arg3 == NULL) SWIG_fail;
13643 temp3 = true;
13644 }
13645 {
13646 PyThreadState* __tstate = wxPyBeginAllowThreads();
13647 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13648 wxPyEndAllowThreads(__tstate);
13649 if (PyErr_Occurred()) SWIG_fail;
13650 }
13651 resultobj = SWIG_Py_Void();
13652 {
13653 if (temp3)
13654 delete arg3;
13655 }
13656 return resultobj;
13657 fail:
13658 {
13659 if (temp3)
13660 delete arg3;
13661 }
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxGrid *arg1 = (wxGrid *) 0 ;
13669 wxColour *arg2 = 0 ;
13670 void *argp1 = 0 ;
13671 int res1 = 0 ;
13672 wxColour temp2 ;
13673 PyObject * obj0 = 0 ;
13674 PyObject * obj1 = 0 ;
13675 char * kwnames[] = {
13676 (char *) "self",(char *)"arg2", NULL
13677 };
13678
13679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13681 if (!SWIG_IsOK(res1)) {
13682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13683 }
13684 arg1 = reinterpret_cast< wxGrid * >(argp1);
13685 {
13686 arg2 = &temp2;
13687 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13688 }
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13692 wxPyEndAllowThreads(__tstate);
13693 if (PyErr_Occurred()) SWIG_fail;
13694 }
13695 resultobj = SWIG_Py_Void();
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13703 PyObject *resultobj = 0;
13704 wxGrid *arg1 = (wxGrid *) 0 ;
13705 wxColour *arg2 = 0 ;
13706 void *argp1 = 0 ;
13707 int res1 = 0 ;
13708 wxColour temp2 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "self",(char *)"arg2", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13719 }
13720 arg1 = reinterpret_cast< wxGrid * >(argp1);
13721 {
13722 arg2 = &temp2;
13723 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13724 }
13725 {
13726 PyThreadState* __tstate = wxPyBeginAllowThreads();
13727 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 resultobj = SWIG_Py_Void();
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj = 0;
13740 wxGrid *arg1 = (wxGrid *) 0 ;
13741 int arg2 ;
13742 void *argp1 = 0 ;
13743 int res1 = 0 ;
13744 int val2 ;
13745 int ecode2 = 0 ;
13746 PyObject * obj0 = 0 ;
13747 PyObject * obj1 = 0 ;
13748 char * kwnames[] = {
13749 (char *) "self",(char *) "width", NULL
13750 };
13751
13752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13754 if (!SWIG_IsOK(res1)) {
13755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13756 }
13757 arg1 = reinterpret_cast< wxGrid * >(argp1);
13758 ecode2 = SWIG_AsVal_int(obj1, &val2);
13759 if (!SWIG_IsOK(ecode2)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13761 }
13762 arg2 = static_cast< int >(val2);
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 (arg1)->SetCellHighlightPenWidth(arg2);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 resultobj = SWIG_Py_Void();
13770 return resultobj;
13771 fail:
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxGrid *arg1 = (wxGrid *) 0 ;
13779 int arg2 ;
13780 void *argp1 = 0 ;
13781 int res1 = 0 ;
13782 int val2 ;
13783 int ecode2 = 0 ;
13784 PyObject * obj0 = 0 ;
13785 PyObject * obj1 = 0 ;
13786 char * kwnames[] = {
13787 (char *) "self",(char *) "width", NULL
13788 };
13789
13790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13792 if (!SWIG_IsOK(res1)) {
13793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13794 }
13795 arg1 = reinterpret_cast< wxGrid * >(argp1);
13796 ecode2 = SWIG_AsVal_int(obj1, &val2);
13797 if (!SWIG_IsOK(ecode2)) {
13798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13799 }
13800 arg2 = static_cast< int >(val2);
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 (arg1)->SetCellHighlightROPenWidth(arg2);
13804 wxPyEndAllowThreads(__tstate);
13805 if (PyErr_Occurred()) SWIG_fail;
13806 }
13807 resultobj = SWIG_Py_Void();
13808 return resultobj;
13809 fail:
13810 return NULL;
13811 }
13812
13813
13814 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13815 PyObject *resultobj = 0;
13816 wxGrid *arg1 = (wxGrid *) 0 ;
13817 bool arg2 = (bool) true ;
13818 void *argp1 = 0 ;
13819 int res1 = 0 ;
13820 bool val2 ;
13821 int ecode2 = 0 ;
13822 PyObject * obj0 = 0 ;
13823 PyObject * obj1 = 0 ;
13824 char * kwnames[] = {
13825 (char *) "self",(char *) "enable", NULL
13826 };
13827
13828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13830 if (!SWIG_IsOK(res1)) {
13831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13832 }
13833 arg1 = reinterpret_cast< wxGrid * >(argp1);
13834 if (obj1) {
13835 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13836 if (!SWIG_IsOK(ecode2)) {
13837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13838 }
13839 arg2 = static_cast< bool >(val2);
13840 }
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 (arg1)->EnableDragRowSize(arg2);
13844 wxPyEndAllowThreads(__tstate);
13845 if (PyErr_Occurred()) SWIG_fail;
13846 }
13847 resultobj = SWIG_Py_Void();
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13855 PyObject *resultobj = 0;
13856 wxGrid *arg1 = (wxGrid *) 0 ;
13857 void *argp1 = 0 ;
13858 int res1 = 0 ;
13859 PyObject *swig_obj[1] ;
13860
13861 if (!args) SWIG_fail;
13862 swig_obj[0] = args;
13863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13864 if (!SWIG_IsOK(res1)) {
13865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13866 }
13867 arg1 = reinterpret_cast< wxGrid * >(argp1);
13868 {
13869 PyThreadState* __tstate = wxPyBeginAllowThreads();
13870 (arg1)->DisableDragRowSize();
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 resultobj = SWIG_Py_Void();
13875 return resultobj;
13876 fail:
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13882 PyObject *resultobj = 0;
13883 wxGrid *arg1 = (wxGrid *) 0 ;
13884 bool result;
13885 void *argp1 = 0 ;
13886 int res1 = 0 ;
13887 PyObject *swig_obj[1] ;
13888
13889 if (!args) SWIG_fail;
13890 swig_obj[0] = args;
13891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13892 if (!SWIG_IsOK(res1)) {
13893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13894 }
13895 arg1 = reinterpret_cast< wxGrid * >(argp1);
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 result = (bool)(arg1)->CanDragRowSize();
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 {
13903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13904 }
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj = 0;
13913 wxGrid *arg1 = (wxGrid *) 0 ;
13914 bool arg2 = (bool) true ;
13915 void *argp1 = 0 ;
13916 int res1 = 0 ;
13917 bool val2 ;
13918 int ecode2 = 0 ;
13919 PyObject * obj0 = 0 ;
13920 PyObject * obj1 = 0 ;
13921 char * kwnames[] = {
13922 (char *) "self",(char *) "enable", NULL
13923 };
13924
13925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13927 if (!SWIG_IsOK(res1)) {
13928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13929 }
13930 arg1 = reinterpret_cast< wxGrid * >(argp1);
13931 if (obj1) {
13932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13933 if (!SWIG_IsOK(ecode2)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13935 }
13936 arg2 = static_cast< bool >(val2);
13937 }
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 (arg1)->EnableDragColSize(arg2);
13941 wxPyEndAllowThreads(__tstate);
13942 if (PyErr_Occurred()) SWIG_fail;
13943 }
13944 resultobj = SWIG_Py_Void();
13945 return resultobj;
13946 fail:
13947 return NULL;
13948 }
13949
13950
13951 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13952 PyObject *resultobj = 0;
13953 wxGrid *arg1 = (wxGrid *) 0 ;
13954 void *argp1 = 0 ;
13955 int res1 = 0 ;
13956 PyObject *swig_obj[1] ;
13957
13958 if (!args) SWIG_fail;
13959 swig_obj[0] = args;
13960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13961 if (!SWIG_IsOK(res1)) {
13962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13963 }
13964 arg1 = reinterpret_cast< wxGrid * >(argp1);
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 (arg1)->DisableDragColSize();
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_Py_Void();
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13979 PyObject *resultobj = 0;
13980 wxGrid *arg1 = (wxGrid *) 0 ;
13981 bool result;
13982 void *argp1 = 0 ;
13983 int res1 = 0 ;
13984 PyObject *swig_obj[1] ;
13985
13986 if (!args) SWIG_fail;
13987 swig_obj[0] = args;
13988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13989 if (!SWIG_IsOK(res1)) {
13990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13991 }
13992 arg1 = reinterpret_cast< wxGrid * >(argp1);
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = (bool)(arg1)->CanDragColSize();
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 {
14000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14001 }
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj = 0;
14010 wxGrid *arg1 = (wxGrid *) 0 ;
14011 bool arg2 = (bool) true ;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 bool val2 ;
14015 int ecode2 = 0 ;
14016 PyObject * obj0 = 0 ;
14017 PyObject * obj1 = 0 ;
14018 char * kwnames[] = {
14019 (char *) "self",(char *) "enable", NULL
14020 };
14021
14022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14024 if (!SWIG_IsOK(res1)) {
14025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14026 }
14027 arg1 = reinterpret_cast< wxGrid * >(argp1);
14028 if (obj1) {
14029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14030 if (!SWIG_IsOK(ecode2)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14032 }
14033 arg2 = static_cast< bool >(val2);
14034 }
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 (arg1)->EnableDragColMove(arg2);
14038 wxPyEndAllowThreads(__tstate);
14039 if (PyErr_Occurred()) SWIG_fail;
14040 }
14041 resultobj = SWIG_Py_Void();
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14049 PyObject *resultobj = 0;
14050 wxGrid *arg1 = (wxGrid *) 0 ;
14051 void *argp1 = 0 ;
14052 int res1 = 0 ;
14053 PyObject *swig_obj[1] ;
14054
14055 if (!args) SWIG_fail;
14056 swig_obj[0] = args;
14057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14060 }
14061 arg1 = reinterpret_cast< wxGrid * >(argp1);
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 (arg1)->DisableDragColMove();
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 resultobj = SWIG_Py_Void();
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14076 PyObject *resultobj = 0;
14077 wxGrid *arg1 = (wxGrid *) 0 ;
14078 bool result;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 PyObject *swig_obj[1] ;
14082
14083 if (!args) SWIG_fail;
14084 swig_obj[0] = args;
14085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14086 if (!SWIG_IsOK(res1)) {
14087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14088 }
14089 arg1 = reinterpret_cast< wxGrid * >(argp1);
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = (bool)(arg1)->CanDragColMove();
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 {
14097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14098 }
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj = 0;
14107 wxGrid *arg1 = (wxGrid *) 0 ;
14108 bool arg2 = (bool) true ;
14109 void *argp1 = 0 ;
14110 int res1 = 0 ;
14111 bool val2 ;
14112 int ecode2 = 0 ;
14113 PyObject * obj0 = 0 ;
14114 PyObject * obj1 = 0 ;
14115 char * kwnames[] = {
14116 (char *) "self",(char *) "enable", NULL
14117 };
14118
14119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14121 if (!SWIG_IsOK(res1)) {
14122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14123 }
14124 arg1 = reinterpret_cast< wxGrid * >(argp1);
14125 if (obj1) {
14126 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14127 if (!SWIG_IsOK(ecode2)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14129 }
14130 arg2 = static_cast< bool >(val2);
14131 }
14132 {
14133 PyThreadState* __tstate = wxPyBeginAllowThreads();
14134 (arg1)->EnableDragGridSize(arg2);
14135 wxPyEndAllowThreads(__tstate);
14136 if (PyErr_Occurred()) SWIG_fail;
14137 }
14138 resultobj = SWIG_Py_Void();
14139 return resultobj;
14140 fail:
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14146 PyObject *resultobj = 0;
14147 wxGrid *arg1 = (wxGrid *) 0 ;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 PyObject *swig_obj[1] ;
14151
14152 if (!args) SWIG_fail;
14153 swig_obj[0] = args;
14154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14155 if (!SWIG_IsOK(res1)) {
14156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14157 }
14158 arg1 = reinterpret_cast< wxGrid * >(argp1);
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 (arg1)->DisableDragGridSize();
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 resultobj = SWIG_Py_Void();
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14173 PyObject *resultobj = 0;
14174 wxGrid *arg1 = (wxGrid *) 0 ;
14175 bool result;
14176 void *argp1 = 0 ;
14177 int res1 = 0 ;
14178 PyObject *swig_obj[1] ;
14179
14180 if (!args) SWIG_fail;
14181 swig_obj[0] = args;
14182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14183 if (!SWIG_IsOK(res1)) {
14184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14185 }
14186 arg1 = reinterpret_cast< wxGrid * >(argp1);
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (bool)(arg1)->CanDragGridSize();
14190 wxPyEndAllowThreads(__tstate);
14191 if (PyErr_Occurred()) SWIG_fail;
14192 }
14193 {
14194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14195 }
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14203 PyObject *resultobj = 0;
14204 wxGrid *arg1 = (wxGrid *) 0 ;
14205 bool arg2 = (bool) true ;
14206 void *argp1 = 0 ;
14207 int res1 = 0 ;
14208 bool val2 ;
14209 int ecode2 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 char * kwnames[] = {
14213 (char *) "self",(char *) "enable", NULL
14214 };
14215
14216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14218 if (!SWIG_IsOK(res1)) {
14219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14220 }
14221 arg1 = reinterpret_cast< wxGrid * >(argp1);
14222 if (obj1) {
14223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14226 }
14227 arg2 = static_cast< bool >(val2);
14228 }
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 (arg1)->EnableDragCell(arg2);
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 resultobj = SWIG_Py_Void();
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 wxGrid *arg1 = (wxGrid *) 0 ;
14245 void *argp1 = 0 ;
14246 int res1 = 0 ;
14247 PyObject *swig_obj[1] ;
14248
14249 if (!args) SWIG_fail;
14250 swig_obj[0] = args;
14251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14252 if (!SWIG_IsOK(res1)) {
14253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14254 }
14255 arg1 = reinterpret_cast< wxGrid * >(argp1);
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 (arg1)->DisableDragCell();
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 resultobj = SWIG_Py_Void();
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14270 PyObject *resultobj = 0;
14271 wxGrid *arg1 = (wxGrid *) 0 ;
14272 bool result;
14273 void *argp1 = 0 ;
14274 int res1 = 0 ;
14275 PyObject *swig_obj[1] ;
14276
14277 if (!args) SWIG_fail;
14278 swig_obj[0] = args;
14279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14280 if (!SWIG_IsOK(res1)) {
14281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14282 }
14283 arg1 = reinterpret_cast< wxGrid * >(argp1);
14284 {
14285 PyThreadState* __tstate = wxPyBeginAllowThreads();
14286 result = (bool)(arg1)->CanDragCell();
14287 wxPyEndAllowThreads(__tstate);
14288 if (PyErr_Occurred()) SWIG_fail;
14289 }
14290 {
14291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14292 }
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj = 0;
14301 wxGrid *arg1 = (wxGrid *) 0 ;
14302 int arg2 ;
14303 int arg3 ;
14304 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14305 void *argp1 = 0 ;
14306 int res1 = 0 ;
14307 int val2 ;
14308 int ecode2 = 0 ;
14309 int val3 ;
14310 int ecode3 = 0 ;
14311 void *argp4 = 0 ;
14312 int res4 = 0 ;
14313 PyObject * obj0 = 0 ;
14314 PyObject * obj1 = 0 ;
14315 PyObject * obj2 = 0 ;
14316 PyObject * obj3 = 0 ;
14317 char * kwnames[] = {
14318 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14319 };
14320
14321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14323 if (!SWIG_IsOK(res1)) {
14324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14325 }
14326 arg1 = reinterpret_cast< wxGrid * >(argp1);
14327 ecode2 = SWIG_AsVal_int(obj1, &val2);
14328 if (!SWIG_IsOK(ecode2)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14330 }
14331 arg2 = static_cast< int >(val2);
14332 ecode3 = SWIG_AsVal_int(obj2, &val3);
14333 if (!SWIG_IsOK(ecode3)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14335 }
14336 arg3 = static_cast< int >(val3);
14337 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14338 if (!SWIG_IsOK(res4)) {
14339 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14340 }
14341 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14342 {
14343 PyThreadState* __tstate = wxPyBeginAllowThreads();
14344 (arg1)->SetAttr(arg2,arg3,arg4);
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 resultobj = SWIG_Py_Void();
14349 return resultobj;
14350 fail:
14351 return NULL;
14352 }
14353
14354
14355 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj = 0;
14357 wxGrid *arg1 = (wxGrid *) 0 ;
14358 int arg2 ;
14359 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14360 void *argp1 = 0 ;
14361 int res1 = 0 ;
14362 int val2 ;
14363 int ecode2 = 0 ;
14364 void *argp3 = 0 ;
14365 int res3 = 0 ;
14366 PyObject * obj0 = 0 ;
14367 PyObject * obj1 = 0 ;
14368 PyObject * obj2 = 0 ;
14369 char * kwnames[] = {
14370 (char *) "self",(char *) "row",(char *) "attr", NULL
14371 };
14372
14373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14375 if (!SWIG_IsOK(res1)) {
14376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14377 }
14378 arg1 = reinterpret_cast< wxGrid * >(argp1);
14379 ecode2 = SWIG_AsVal_int(obj1, &val2);
14380 if (!SWIG_IsOK(ecode2)) {
14381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14382 }
14383 arg2 = static_cast< int >(val2);
14384 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14385 if (!SWIG_IsOK(res3)) {
14386 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14387 }
14388 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14389 {
14390 PyThreadState* __tstate = wxPyBeginAllowThreads();
14391 (arg1)->SetRowAttr(arg2,arg3);
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 resultobj = SWIG_Py_Void();
14396 return resultobj;
14397 fail:
14398 return NULL;
14399 }
14400
14401
14402 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj = 0;
14404 wxGrid *arg1 = (wxGrid *) 0 ;
14405 int arg2 ;
14406 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14407 void *argp1 = 0 ;
14408 int res1 = 0 ;
14409 int val2 ;
14410 int ecode2 = 0 ;
14411 void *argp3 = 0 ;
14412 int res3 = 0 ;
14413 PyObject * obj0 = 0 ;
14414 PyObject * obj1 = 0 ;
14415 PyObject * obj2 = 0 ;
14416 char * kwnames[] = {
14417 (char *) "self",(char *) "col",(char *) "attr", NULL
14418 };
14419
14420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14422 if (!SWIG_IsOK(res1)) {
14423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14424 }
14425 arg1 = reinterpret_cast< wxGrid * >(argp1);
14426 ecode2 = SWIG_AsVal_int(obj1, &val2);
14427 if (!SWIG_IsOK(ecode2)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14429 }
14430 arg2 = static_cast< int >(val2);
14431 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14432 if (!SWIG_IsOK(res3)) {
14433 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14434 }
14435 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 (arg1)->SetColAttr(arg2,arg3);
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = SWIG_Py_Void();
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj = 0;
14451 wxGrid *arg1 = (wxGrid *) 0 ;
14452 int arg2 ;
14453 int arg3 ;
14454 wxGridCellAttr *result = 0 ;
14455 void *argp1 = 0 ;
14456 int res1 = 0 ;
14457 int val2 ;
14458 int ecode2 = 0 ;
14459 int val3 ;
14460 int ecode3 = 0 ;
14461 PyObject * obj0 = 0 ;
14462 PyObject * obj1 = 0 ;
14463 PyObject * obj2 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "self",(char *) "row",(char *) "col", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14472 }
14473 arg1 = reinterpret_cast< wxGrid * >(argp1);
14474 ecode2 = SWIG_AsVal_int(obj1, &val2);
14475 if (!SWIG_IsOK(ecode2)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14477 }
14478 arg2 = static_cast< int >(val2);
14479 ecode3 = SWIG_AsVal_int(obj2, &val3);
14480 if (!SWIG_IsOK(ecode3)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14482 }
14483 arg3 = static_cast< int >(val3);
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 {
14491 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14492 }
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxGrid *arg1 = (wxGrid *) 0 ;
14502 int arg2 ;
14503 void *argp1 = 0 ;
14504 int res1 = 0 ;
14505 int val2 ;
14506 int ecode2 = 0 ;
14507 PyObject * obj0 = 0 ;
14508 PyObject * obj1 = 0 ;
14509 char * kwnames[] = {
14510 (char *) "self",(char *) "col", NULL
14511 };
14512
14513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14515 if (!SWIG_IsOK(res1)) {
14516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14517 }
14518 arg1 = reinterpret_cast< wxGrid * >(argp1);
14519 ecode2 = SWIG_AsVal_int(obj1, &val2);
14520 if (!SWIG_IsOK(ecode2)) {
14521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14522 }
14523 arg2 = static_cast< int >(val2);
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 (arg1)->SetColFormatBool(arg2);
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 resultobj = SWIG_Py_Void();
14531 return resultobj;
14532 fail:
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = 0;
14539 wxGrid *arg1 = (wxGrid *) 0 ;
14540 int arg2 ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 int val2 ;
14544 int ecode2 = 0 ;
14545 PyObject * obj0 = 0 ;
14546 PyObject * obj1 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "col", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14555 }
14556 arg1 = reinterpret_cast< wxGrid * >(argp1);
14557 ecode2 = SWIG_AsVal_int(obj1, &val2);
14558 if (!SWIG_IsOK(ecode2)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14560 }
14561 arg2 = static_cast< int >(val2);
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->SetColFormatNumber(arg2);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14576 PyObject *resultobj = 0;
14577 wxGrid *arg1 = (wxGrid *) 0 ;
14578 int arg2 ;
14579 int arg3 = (int) -1 ;
14580 int arg4 = (int) -1 ;
14581 void *argp1 = 0 ;
14582 int res1 = 0 ;
14583 int val2 ;
14584 int ecode2 = 0 ;
14585 int val3 ;
14586 int ecode3 = 0 ;
14587 int val4 ;
14588 int ecode4 = 0 ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 PyObject * obj2 = 0 ;
14592 PyObject * obj3 = 0 ;
14593 char * kwnames[] = {
14594 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14595 };
14596
14597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14599 if (!SWIG_IsOK(res1)) {
14600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14601 }
14602 arg1 = reinterpret_cast< wxGrid * >(argp1);
14603 ecode2 = SWIG_AsVal_int(obj1, &val2);
14604 if (!SWIG_IsOK(ecode2)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14606 }
14607 arg2 = static_cast< int >(val2);
14608 if (obj2) {
14609 ecode3 = SWIG_AsVal_int(obj2, &val3);
14610 if (!SWIG_IsOK(ecode3)) {
14611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14612 }
14613 arg3 = static_cast< int >(val3);
14614 }
14615 if (obj3) {
14616 ecode4 = SWIG_AsVal_int(obj3, &val4);
14617 if (!SWIG_IsOK(ecode4)) {
14618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14619 }
14620 arg4 = static_cast< int >(val4);
14621 }
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14625 wxPyEndAllowThreads(__tstate);
14626 if (PyErr_Occurred()) SWIG_fail;
14627 }
14628 resultobj = SWIG_Py_Void();
14629 return resultobj;
14630 fail:
14631 return NULL;
14632 }
14633
14634
14635 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14636 PyObject *resultobj = 0;
14637 wxGrid *arg1 = (wxGrid *) 0 ;
14638 int arg2 ;
14639 wxString *arg3 = 0 ;
14640 void *argp1 = 0 ;
14641 int res1 = 0 ;
14642 int val2 ;
14643 int ecode2 = 0 ;
14644 bool temp3 = false ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 char * kwnames[] = {
14649 (char *) "self",(char *) "col",(char *) "typeName", NULL
14650 };
14651
14652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14654 if (!SWIG_IsOK(res1)) {
14655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14656 }
14657 arg1 = reinterpret_cast< wxGrid * >(argp1);
14658 ecode2 = SWIG_AsVal_int(obj1, &val2);
14659 if (!SWIG_IsOK(ecode2)) {
14660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14661 }
14662 arg2 = static_cast< int >(val2);
14663 {
14664 arg3 = wxString_in_helper(obj2);
14665 if (arg3 == NULL) SWIG_fail;
14666 temp3 = true;
14667 }
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 resultobj = SWIG_Py_Void();
14675 {
14676 if (temp3)
14677 delete arg3;
14678 }
14679 return resultobj;
14680 fail:
14681 {
14682 if (temp3)
14683 delete arg3;
14684 }
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj = 0;
14691 wxGrid *arg1 = (wxGrid *) 0 ;
14692 bool arg2 = (bool) true ;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 bool val2 ;
14696 int ecode2 = 0 ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char * kwnames[] = {
14700 (char *) "self",(char *) "enable", NULL
14701 };
14702
14703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14707 }
14708 arg1 = reinterpret_cast< wxGrid * >(argp1);
14709 if (obj1) {
14710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14711 if (!SWIG_IsOK(ecode2)) {
14712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14713 }
14714 arg2 = static_cast< bool >(val2);
14715 }
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 (arg1)->EnableGridLines(arg2);
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 resultobj = SWIG_Py_Void();
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxGrid *arg1 = (wxGrid *) 0 ;
14732 bool result;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14742 }
14743 arg1 = reinterpret_cast< wxGrid * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (bool)(arg1)->GridLinesEnabled();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 {
14751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752 }
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14760 PyObject *resultobj = 0;
14761 wxGrid *arg1 = (wxGrid *) 0 ;
14762 int result;
14763 void *argp1 = 0 ;
14764 int res1 = 0 ;
14765 PyObject *swig_obj[1] ;
14766
14767 if (!args) SWIG_fail;
14768 swig_obj[0] = args;
14769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14770 if (!SWIG_IsOK(res1)) {
14771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14772 }
14773 arg1 = reinterpret_cast< wxGrid * >(argp1);
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (int)(arg1)->GetDefaultRowSize();
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 resultobj = SWIG_From_int(static_cast< int >(result));
14781 return resultobj;
14782 fail:
14783 return NULL;
14784 }
14785
14786
14787 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14788 PyObject *resultobj = 0;
14789 wxGrid *arg1 = (wxGrid *) 0 ;
14790 int arg2 ;
14791 int result;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 int val2 ;
14795 int ecode2 = 0 ;
14796 PyObject * obj0 = 0 ;
14797 PyObject * obj1 = 0 ;
14798 char * kwnames[] = {
14799 (char *) "self",(char *) "row", NULL
14800 };
14801
14802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14804 if (!SWIG_IsOK(res1)) {
14805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14806 }
14807 arg1 = reinterpret_cast< wxGrid * >(argp1);
14808 ecode2 = SWIG_AsVal_int(obj1, &val2);
14809 if (!SWIG_IsOK(ecode2)) {
14810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14811 }
14812 arg2 = static_cast< int >(val2);
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = (int)(arg1)->GetRowSize(arg2);
14816 wxPyEndAllowThreads(__tstate);
14817 if (PyErr_Occurred()) SWIG_fail;
14818 }
14819 resultobj = SWIG_From_int(static_cast< int >(result));
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *resultobj = 0;
14828 wxGrid *arg1 = (wxGrid *) 0 ;
14829 int result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 PyObject *swig_obj[1] ;
14833
14834 if (!args) SWIG_fail;
14835 swig_obj[0] = args;
14836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14839 }
14840 arg1 = reinterpret_cast< wxGrid * >(argp1);
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (int)(arg1)->GetDefaultColSize();
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 resultobj = SWIG_From_int(static_cast< int >(result));
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj = 0;
14856 wxGrid *arg1 = (wxGrid *) 0 ;
14857 int arg2 ;
14858 int result;
14859 void *argp1 = 0 ;
14860 int res1 = 0 ;
14861 int val2 ;
14862 int ecode2 = 0 ;
14863 PyObject * obj0 = 0 ;
14864 PyObject * obj1 = 0 ;
14865 char * kwnames[] = {
14866 (char *) "self",(char *) "col", NULL
14867 };
14868
14869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14871 if (!SWIG_IsOK(res1)) {
14872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14873 }
14874 arg1 = reinterpret_cast< wxGrid * >(argp1);
14875 ecode2 = SWIG_AsVal_int(obj1, &val2);
14876 if (!SWIG_IsOK(ecode2)) {
14877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14878 }
14879 arg2 = static_cast< int >(val2);
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (int)(arg1)->GetColSize(arg2);
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 resultobj = SWIG_From_int(static_cast< int >(result));
14887 return resultobj;
14888 fail:
14889 return NULL;
14890 }
14891
14892
14893 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14894 PyObject *resultobj = 0;
14895 wxGrid *arg1 = (wxGrid *) 0 ;
14896 wxColour result;
14897 void *argp1 = 0 ;
14898 int res1 = 0 ;
14899 PyObject *swig_obj[1] ;
14900
14901 if (!args) SWIG_fail;
14902 swig_obj[0] = args;
14903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14904 if (!SWIG_IsOK(res1)) {
14905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14906 }
14907 arg1 = reinterpret_cast< wxGrid * >(argp1);
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (arg1)->GetDefaultCellBackgroundColour();
14911 wxPyEndAllowThreads(__tstate);
14912 if (PyErr_Occurred()) SWIG_fail;
14913 }
14914 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14915 return resultobj;
14916 fail:
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj = 0;
14923 wxGrid *arg1 = (wxGrid *) 0 ;
14924 int arg2 ;
14925 int arg3 ;
14926 wxColour result;
14927 void *argp1 = 0 ;
14928 int res1 = 0 ;
14929 int val2 ;
14930 int ecode2 = 0 ;
14931 int val3 ;
14932 int ecode3 = 0 ;
14933 PyObject * obj0 = 0 ;
14934 PyObject * obj1 = 0 ;
14935 PyObject * obj2 = 0 ;
14936 char * kwnames[] = {
14937 (char *) "self",(char *) "row",(char *) "col", NULL
14938 };
14939
14940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14944 }
14945 arg1 = reinterpret_cast< wxGrid * >(argp1);
14946 ecode2 = SWIG_AsVal_int(obj1, &val2);
14947 if (!SWIG_IsOK(ecode2)) {
14948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14949 }
14950 arg2 = static_cast< int >(val2);
14951 ecode3 = SWIG_AsVal_int(obj2, &val3);
14952 if (!SWIG_IsOK(ecode3)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14954 }
14955 arg3 = static_cast< int >(val3);
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxGrid *arg1 = (wxGrid *) 0 ;
14972 wxColour result;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 PyObject *swig_obj[1] ;
14976
14977 if (!args) SWIG_fail;
14978 swig_obj[0] = args;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14982 }
14983 arg1 = reinterpret_cast< wxGrid * >(argp1);
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 result = (arg1)->GetDefaultCellTextColour();
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj = 0;
14999 wxGrid *arg1 = (wxGrid *) 0 ;
15000 int arg2 ;
15001 int arg3 ;
15002 wxColour result;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 int val2 ;
15006 int ecode2 = 0 ;
15007 int val3 ;
15008 int ecode3 = 0 ;
15009 PyObject * obj0 = 0 ;
15010 PyObject * obj1 = 0 ;
15011 PyObject * obj2 = 0 ;
15012 char * kwnames[] = {
15013 (char *) "self",(char *) "row",(char *) "col", NULL
15014 };
15015
15016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15018 if (!SWIG_IsOK(res1)) {
15019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15020 }
15021 arg1 = reinterpret_cast< wxGrid * >(argp1);
15022 ecode2 = SWIG_AsVal_int(obj1, &val2);
15023 if (!SWIG_IsOK(ecode2)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15025 }
15026 arg2 = static_cast< int >(val2);
15027 ecode3 = SWIG_AsVal_int(obj2, &val3);
15028 if (!SWIG_IsOK(ecode3)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15030 }
15031 arg3 = static_cast< int >(val3);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (arg1)->GetCellTextColour(arg2,arg3);
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *resultobj = 0;
15047 wxGrid *arg1 = (wxGrid *) 0 ;
15048 wxFont result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 PyObject *swig_obj[1] ;
15052
15053 if (!args) SWIG_fail;
15054 swig_obj[0] = args;
15055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15058 }
15059 arg1 = reinterpret_cast< wxGrid * >(argp1);
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (arg1)->GetDefaultCellFont();
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15074 PyObject *resultobj = 0;
15075 wxGrid *arg1 = (wxGrid *) 0 ;
15076 int arg2 ;
15077 int arg3 ;
15078 wxFont result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 int val2 ;
15082 int ecode2 = 0 ;
15083 int val3 ;
15084 int ecode3 = 0 ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 PyObject * obj2 = 0 ;
15088 char * kwnames[] = {
15089 (char *) "self",(char *) "row",(char *) "col", NULL
15090 };
15091
15092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15096 }
15097 arg1 = reinterpret_cast< wxGrid * >(argp1);
15098 ecode2 = SWIG_AsVal_int(obj1, &val2);
15099 if (!SWIG_IsOK(ecode2)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15101 }
15102 arg2 = static_cast< int >(val2);
15103 ecode3 = SWIG_AsVal_int(obj2, &val3);
15104 if (!SWIG_IsOK(ecode3)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15106 }
15107 arg3 = static_cast< int >(val3);
15108 {
15109 PyThreadState* __tstate = wxPyBeginAllowThreads();
15110 result = (arg1)->GetCellFont(arg2,arg3);
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15122 PyObject *resultobj = 0;
15123 wxGrid *arg1 = (wxGrid *) 0 ;
15124 int *arg2 = (int *) 0 ;
15125 int *arg3 = (int *) 0 ;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 int temp2 ;
15129 int res2 = SWIG_TMPOBJ ;
15130 int temp3 ;
15131 int res3 = SWIG_TMPOBJ ;
15132 PyObject *swig_obj[1] ;
15133
15134 arg2 = &temp2;
15135 arg3 = &temp3;
15136 if (!args) SWIG_fail;
15137 swig_obj[0] = args;
15138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15139 if (!SWIG_IsOK(res1)) {
15140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15141 }
15142 arg1 = reinterpret_cast< wxGrid * >(argp1);
15143 {
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_Py_Void();
15150 if (SWIG_IsTmpObj(res2)) {
15151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15152 } else {
15153 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15155 }
15156 if (SWIG_IsTmpObj(res3)) {
15157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15158 } else {
15159 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15161 }
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj = 0;
15170 wxGrid *arg1 = (wxGrid *) 0 ;
15171 int arg2 ;
15172 int arg3 ;
15173 int *arg4 = (int *) 0 ;
15174 int *arg5 = (int *) 0 ;
15175 void *argp1 = 0 ;
15176 int res1 = 0 ;
15177 int val2 ;
15178 int ecode2 = 0 ;
15179 int val3 ;
15180 int ecode3 = 0 ;
15181 int temp4 ;
15182 int res4 = SWIG_TMPOBJ ;
15183 int temp5 ;
15184 int res5 = SWIG_TMPOBJ ;
15185 PyObject * obj0 = 0 ;
15186 PyObject * obj1 = 0 ;
15187 PyObject * obj2 = 0 ;
15188 char * kwnames[] = {
15189 (char *) "self",(char *) "row",(char *) "col", NULL
15190 };
15191
15192 arg4 = &temp4;
15193 arg5 = &temp5;
15194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15196 if (!SWIG_IsOK(res1)) {
15197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15198 }
15199 arg1 = reinterpret_cast< wxGrid * >(argp1);
15200 ecode2 = SWIG_AsVal_int(obj1, &val2);
15201 if (!SWIG_IsOK(ecode2)) {
15202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15203 }
15204 arg2 = static_cast< int >(val2);
15205 ecode3 = SWIG_AsVal_int(obj2, &val3);
15206 if (!SWIG_IsOK(ecode3)) {
15207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15208 }
15209 arg3 = static_cast< int >(val3);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 resultobj = SWIG_Py_Void();
15217 if (SWIG_IsTmpObj(res4)) {
15218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15219 } else {
15220 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15222 }
15223 if (SWIG_IsTmpObj(res5)) {
15224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15225 } else {
15226 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15228 }
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 PyObject *resultobj = 0;
15237 wxGrid *arg1 = (wxGrid *) 0 ;
15238 bool result;
15239 void *argp1 = 0 ;
15240 int res1 = 0 ;
15241 PyObject *swig_obj[1] ;
15242
15243 if (!args) SWIG_fail;
15244 swig_obj[0] = args;
15245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15246 if (!SWIG_IsOK(res1)) {
15247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15248 }
15249 arg1 = reinterpret_cast< wxGrid * >(argp1);
15250 {
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (bool)(arg1)->GetDefaultCellOverflow();
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 {
15257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15258 }
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15266 PyObject *resultobj = 0;
15267 wxGrid *arg1 = (wxGrid *) 0 ;
15268 int arg2 ;
15269 int arg3 ;
15270 bool result;
15271 void *argp1 = 0 ;
15272 int res1 = 0 ;
15273 int val2 ;
15274 int ecode2 = 0 ;
15275 int val3 ;
15276 int ecode3 = 0 ;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 PyObject * obj2 = 0 ;
15280 char * kwnames[] = {
15281 (char *) "self",(char *) "row",(char *) "col", NULL
15282 };
15283
15284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15286 if (!SWIG_IsOK(res1)) {
15287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15288 }
15289 arg1 = reinterpret_cast< wxGrid * >(argp1);
15290 ecode2 = SWIG_AsVal_int(obj1, &val2);
15291 if (!SWIG_IsOK(ecode2)) {
15292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15293 }
15294 arg2 = static_cast< int >(val2);
15295 ecode3 = SWIG_AsVal_int(obj2, &val3);
15296 if (!SWIG_IsOK(ecode3)) {
15297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15298 }
15299 arg3 = static_cast< int >(val3);
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 {
15307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15308 }
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15316 PyObject *resultobj = 0;
15317 wxGrid *arg1 = (wxGrid *) 0 ;
15318 int arg2 ;
15319 int arg3 ;
15320 int *arg4 = (int *) 0 ;
15321 int *arg5 = (int *) 0 ;
15322 void *argp1 = 0 ;
15323 int res1 = 0 ;
15324 int val2 ;
15325 int ecode2 = 0 ;
15326 int val3 ;
15327 int ecode3 = 0 ;
15328 int temp4 ;
15329 int res4 = SWIG_TMPOBJ ;
15330 int temp5 ;
15331 int res5 = SWIG_TMPOBJ ;
15332 PyObject * obj0 = 0 ;
15333 PyObject * obj1 = 0 ;
15334 PyObject * obj2 = 0 ;
15335 char * kwnames[] = {
15336 (char *) "self",(char *) "row",(char *) "col", NULL
15337 };
15338
15339 arg4 = &temp4;
15340 arg5 = &temp5;
15341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15343 if (!SWIG_IsOK(res1)) {
15344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15345 }
15346 arg1 = reinterpret_cast< wxGrid * >(argp1);
15347 ecode2 = SWIG_AsVal_int(obj1, &val2);
15348 if (!SWIG_IsOK(ecode2)) {
15349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15350 }
15351 arg2 = static_cast< int >(val2);
15352 ecode3 = SWIG_AsVal_int(obj2, &val3);
15353 if (!SWIG_IsOK(ecode3)) {
15354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15355 }
15356 arg3 = static_cast< int >(val3);
15357 {
15358 PyThreadState* __tstate = wxPyBeginAllowThreads();
15359 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 resultobj = SWIG_Py_Void();
15364 if (SWIG_IsTmpObj(res4)) {
15365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15366 } else {
15367 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15369 }
15370 if (SWIG_IsTmpObj(res5)) {
15371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15372 } else {
15373 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15375 }
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj = 0;
15384 wxGrid *arg1 = (wxGrid *) 0 ;
15385 int arg2 ;
15386 bool arg3 = (bool) false ;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 int val2 ;
15390 int ecode2 = 0 ;
15391 bool val3 ;
15392 int ecode3 = 0 ;
15393 PyObject * obj0 = 0 ;
15394 PyObject * obj1 = 0 ;
15395 PyObject * obj2 = 0 ;
15396 char * kwnames[] = {
15397 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15398 };
15399
15400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15402 if (!SWIG_IsOK(res1)) {
15403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15404 }
15405 arg1 = reinterpret_cast< wxGrid * >(argp1);
15406 ecode2 = SWIG_AsVal_int(obj1, &val2);
15407 if (!SWIG_IsOK(ecode2)) {
15408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15409 }
15410 arg2 = static_cast< int >(val2);
15411 if (obj2) {
15412 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15413 if (!SWIG_IsOK(ecode3)) {
15414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15415 }
15416 arg3 = static_cast< bool >(val3);
15417 }
15418 {
15419 PyThreadState* __tstate = wxPyBeginAllowThreads();
15420 (arg1)->SetDefaultRowSize(arg2,arg3);
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 resultobj = SWIG_Py_Void();
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15432 PyObject *resultobj = 0;
15433 wxGrid *arg1 = (wxGrid *) 0 ;
15434 int arg2 ;
15435 int arg3 ;
15436 void *argp1 = 0 ;
15437 int res1 = 0 ;
15438 int val2 ;
15439 int ecode2 = 0 ;
15440 int val3 ;
15441 int ecode3 = 0 ;
15442 PyObject * obj0 = 0 ;
15443 PyObject * obj1 = 0 ;
15444 PyObject * obj2 = 0 ;
15445 char * kwnames[] = {
15446 (char *) "self",(char *) "row",(char *) "height", NULL
15447 };
15448
15449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15453 }
15454 arg1 = reinterpret_cast< wxGrid * >(argp1);
15455 ecode2 = SWIG_AsVal_int(obj1, &val2);
15456 if (!SWIG_IsOK(ecode2)) {
15457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15458 }
15459 arg2 = static_cast< int >(val2);
15460 ecode3 = SWIG_AsVal_int(obj2, &val3);
15461 if (!SWIG_IsOK(ecode3)) {
15462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15463 }
15464 arg3 = static_cast< int >(val3);
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 (arg1)->SetRowSize(arg2,arg3);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = SWIG_Py_Void();
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15479 PyObject *resultobj = 0;
15480 wxGrid *arg1 = (wxGrid *) 0 ;
15481 int arg2 ;
15482 bool arg3 = (bool) false ;
15483 void *argp1 = 0 ;
15484 int res1 = 0 ;
15485 int val2 ;
15486 int ecode2 = 0 ;
15487 bool val3 ;
15488 int ecode3 = 0 ;
15489 PyObject * obj0 = 0 ;
15490 PyObject * obj1 = 0 ;
15491 PyObject * obj2 = 0 ;
15492 char * kwnames[] = {
15493 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15494 };
15495
15496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15498 if (!SWIG_IsOK(res1)) {
15499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15500 }
15501 arg1 = reinterpret_cast< wxGrid * >(argp1);
15502 ecode2 = SWIG_AsVal_int(obj1, &val2);
15503 if (!SWIG_IsOK(ecode2)) {
15504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15505 }
15506 arg2 = static_cast< int >(val2);
15507 if (obj2) {
15508 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15509 if (!SWIG_IsOK(ecode3)) {
15510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15511 }
15512 arg3 = static_cast< bool >(val3);
15513 }
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 (arg1)->SetDefaultColSize(arg2,arg3);
15517 wxPyEndAllowThreads(__tstate);
15518 if (PyErr_Occurred()) SWIG_fail;
15519 }
15520 resultobj = SWIG_Py_Void();
15521 return resultobj;
15522 fail:
15523 return NULL;
15524 }
15525
15526
15527 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15528 PyObject *resultobj = 0;
15529 wxGrid *arg1 = (wxGrid *) 0 ;
15530 int arg2 ;
15531 int arg3 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 int val2 ;
15535 int ecode2 = 0 ;
15536 int val3 ;
15537 int ecode3 = 0 ;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 PyObject * obj2 = 0 ;
15541 char * kwnames[] = {
15542 (char *) "self",(char *) "col",(char *) "width", NULL
15543 };
15544
15545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15549 }
15550 arg1 = reinterpret_cast< wxGrid * >(argp1);
15551 ecode2 = SWIG_AsVal_int(obj1, &val2);
15552 if (!SWIG_IsOK(ecode2)) {
15553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15554 }
15555 arg2 = static_cast< int >(val2);
15556 ecode3 = SWIG_AsVal_int(obj2, &val3);
15557 if (!SWIG_IsOK(ecode3)) {
15558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15559 }
15560 arg3 = static_cast< int >(val3);
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 (arg1)->SetColSize(arg2,arg3);
15564 wxPyEndAllowThreads(__tstate);
15565 if (PyErr_Occurred()) SWIG_fail;
15566 }
15567 resultobj = SWIG_Py_Void();
15568 return resultobj;
15569 fail:
15570 return NULL;
15571 }
15572
15573
15574 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15575 PyObject *resultobj = 0;
15576 wxGrid *arg1 = (wxGrid *) 0 ;
15577 int arg2 ;
15578 int result;
15579 void *argp1 = 0 ;
15580 int res1 = 0 ;
15581 int val2 ;
15582 int ecode2 = 0 ;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 char * kwnames[] = {
15586 (char *) "self",(char *) "colPos", NULL
15587 };
15588
15589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15591 if (!SWIG_IsOK(res1)) {
15592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15593 }
15594 arg1 = reinterpret_cast< wxGrid * >(argp1);
15595 ecode2 = SWIG_AsVal_int(obj1, &val2);
15596 if (!SWIG_IsOK(ecode2)) {
15597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15598 }
15599 arg2 = static_cast< int >(val2);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = SWIG_From_int(static_cast< int >(result));
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15614 PyObject *resultobj = 0;
15615 wxGrid *arg1 = (wxGrid *) 0 ;
15616 int arg2 ;
15617 int arg3 ;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 int val2 ;
15621 int ecode2 = 0 ;
15622 int val3 ;
15623 int ecode3 = 0 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 PyObject * obj2 = 0 ;
15627 char * kwnames[] = {
15628 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15629 };
15630
15631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15635 }
15636 arg1 = reinterpret_cast< wxGrid * >(argp1);
15637 ecode2 = SWIG_AsVal_int(obj1, &val2);
15638 if (!SWIG_IsOK(ecode2)) {
15639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15640 }
15641 arg2 = static_cast< int >(val2);
15642 ecode3 = SWIG_AsVal_int(obj2, &val3);
15643 if (!SWIG_IsOK(ecode3)) {
15644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15645 }
15646 arg3 = static_cast< int >(val3);
15647 {
15648 PyThreadState* __tstate = wxPyBeginAllowThreads();
15649 (arg1)->SetColPos(arg2,arg3);
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 resultobj = SWIG_Py_Void();
15654 return resultobj;
15655 fail:
15656 return NULL;
15657 }
15658
15659
15660 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15661 PyObject *resultobj = 0;
15662 wxGrid *arg1 = (wxGrid *) 0 ;
15663 int arg2 ;
15664 int result;
15665 void *argp1 = 0 ;
15666 int res1 = 0 ;
15667 int val2 ;
15668 int ecode2 = 0 ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 char * kwnames[] = {
15672 (char *) "self",(char *) "colID", NULL
15673 };
15674
15675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15677 if (!SWIG_IsOK(res1)) {
15678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15679 }
15680 arg1 = reinterpret_cast< wxGrid * >(argp1);
15681 ecode2 = SWIG_AsVal_int(obj1, &val2);
15682 if (!SWIG_IsOK(ecode2)) {
15683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15684 }
15685 arg2 = static_cast< int >(val2);
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 resultobj = SWIG_From_int(static_cast< int >(result));
15693 return resultobj;
15694 fail:
15695 return NULL;
15696 }
15697
15698
15699 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15700 PyObject *resultobj = 0;
15701 wxGrid *arg1 = (wxGrid *) 0 ;
15702 int arg2 ;
15703 bool arg3 = (bool) true ;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 int val2 ;
15707 int ecode2 = 0 ;
15708 bool val3 ;
15709 int ecode3 = 0 ;
15710 PyObject * obj0 = 0 ;
15711 PyObject * obj1 = 0 ;
15712 PyObject * obj2 = 0 ;
15713 char * kwnames[] = {
15714 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15715 };
15716
15717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15719 if (!SWIG_IsOK(res1)) {
15720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15721 }
15722 arg1 = reinterpret_cast< wxGrid * >(argp1);
15723 ecode2 = SWIG_AsVal_int(obj1, &val2);
15724 if (!SWIG_IsOK(ecode2)) {
15725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15726 }
15727 arg2 = static_cast< int >(val2);
15728 if (obj2) {
15729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15730 if (!SWIG_IsOK(ecode3)) {
15731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15732 }
15733 arg3 = static_cast< bool >(val3);
15734 }
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 (arg1)->AutoSizeColumn(arg2,arg3);
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = SWIG_Py_Void();
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = 0;
15750 wxGrid *arg1 = (wxGrid *) 0 ;
15751 int arg2 ;
15752 bool arg3 = (bool) true ;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 int val2 ;
15756 int ecode2 = 0 ;
15757 bool val3 ;
15758 int ecode3 = 0 ;
15759 PyObject * obj0 = 0 ;
15760 PyObject * obj1 = 0 ;
15761 PyObject * obj2 = 0 ;
15762 char * kwnames[] = {
15763 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15764 };
15765
15766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15770 }
15771 arg1 = reinterpret_cast< wxGrid * >(argp1);
15772 ecode2 = SWIG_AsVal_int(obj1, &val2);
15773 if (!SWIG_IsOK(ecode2)) {
15774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15775 }
15776 arg2 = static_cast< int >(val2);
15777 if (obj2) {
15778 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15779 if (!SWIG_IsOK(ecode3)) {
15780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15781 }
15782 arg3 = static_cast< bool >(val3);
15783 }
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 (arg1)->AutoSizeRow(arg2,arg3);
15787 wxPyEndAllowThreads(__tstate);
15788 if (PyErr_Occurred()) SWIG_fail;
15789 }
15790 resultobj = SWIG_Py_Void();
15791 return resultobj;
15792 fail:
15793 return NULL;
15794 }
15795
15796
15797 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15798 PyObject *resultobj = 0;
15799 wxGrid *arg1 = (wxGrid *) 0 ;
15800 bool arg2 = (bool) true ;
15801 void *argp1 = 0 ;
15802 int res1 = 0 ;
15803 bool val2 ;
15804 int ecode2 = 0 ;
15805 PyObject * obj0 = 0 ;
15806 PyObject * obj1 = 0 ;
15807 char * kwnames[] = {
15808 (char *) "self",(char *) "setAsMin", NULL
15809 };
15810
15811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15815 }
15816 arg1 = reinterpret_cast< wxGrid * >(argp1);
15817 if (obj1) {
15818 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15819 if (!SWIG_IsOK(ecode2)) {
15820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15821 }
15822 arg2 = static_cast< bool >(val2);
15823 }
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 (arg1)->AutoSizeColumns(arg2);
15827 wxPyEndAllowThreads(__tstate);
15828 if (PyErr_Occurred()) SWIG_fail;
15829 }
15830 resultobj = SWIG_Py_Void();
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15838 PyObject *resultobj = 0;
15839 wxGrid *arg1 = (wxGrid *) 0 ;
15840 bool arg2 = (bool) true ;
15841 void *argp1 = 0 ;
15842 int res1 = 0 ;
15843 bool val2 ;
15844 int ecode2 = 0 ;
15845 PyObject * obj0 = 0 ;
15846 PyObject * obj1 = 0 ;
15847 char * kwnames[] = {
15848 (char *) "self",(char *) "setAsMin", NULL
15849 };
15850
15851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15853 if (!SWIG_IsOK(res1)) {
15854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15855 }
15856 arg1 = reinterpret_cast< wxGrid * >(argp1);
15857 if (obj1) {
15858 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15859 if (!SWIG_IsOK(ecode2)) {
15860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15861 }
15862 arg2 = static_cast< bool >(val2);
15863 }
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 (arg1)->AutoSizeRows(arg2);
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_Py_Void();
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxGrid *arg1 = (wxGrid *) 0 ;
15880 void *argp1 = 0 ;
15881 int res1 = 0 ;
15882 PyObject *swig_obj[1] ;
15883
15884 if (!args) SWIG_fail;
15885 swig_obj[0] = args;
15886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15887 if (!SWIG_IsOK(res1)) {
15888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15889 }
15890 arg1 = reinterpret_cast< wxGrid * >(argp1);
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 (arg1)->AutoSize();
15894 wxPyEndAllowThreads(__tstate);
15895 if (PyErr_Occurred()) SWIG_fail;
15896 }
15897 resultobj = SWIG_Py_Void();
15898 return resultobj;
15899 fail:
15900 return NULL;
15901 }
15902
15903
15904 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15905 PyObject *resultobj = 0;
15906 wxGrid *arg1 = (wxGrid *) 0 ;
15907 int arg2 ;
15908 void *argp1 = 0 ;
15909 int res1 = 0 ;
15910 int val2 ;
15911 int ecode2 = 0 ;
15912 PyObject * obj0 = 0 ;
15913 PyObject * obj1 = 0 ;
15914 char * kwnames[] = {
15915 (char *) "self",(char *) "row", NULL
15916 };
15917
15918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15920 if (!SWIG_IsOK(res1)) {
15921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15922 }
15923 arg1 = reinterpret_cast< wxGrid * >(argp1);
15924 ecode2 = SWIG_AsVal_int(obj1, &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15927 }
15928 arg2 = static_cast< int >(val2);
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 (arg1)->AutoSizeRowLabelSize(arg2);
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_Py_Void();
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15943 PyObject *resultobj = 0;
15944 wxGrid *arg1 = (wxGrid *) 0 ;
15945 int arg2 ;
15946 void *argp1 = 0 ;
15947 int res1 = 0 ;
15948 int val2 ;
15949 int ecode2 = 0 ;
15950 PyObject * obj0 = 0 ;
15951 PyObject * obj1 = 0 ;
15952 char * kwnames[] = {
15953 (char *) "self",(char *) "col", NULL
15954 };
15955
15956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15958 if (!SWIG_IsOK(res1)) {
15959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15960 }
15961 arg1 = reinterpret_cast< wxGrid * >(argp1);
15962 ecode2 = SWIG_AsVal_int(obj1, &val2);
15963 if (!SWIG_IsOK(ecode2)) {
15964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15965 }
15966 arg2 = static_cast< int >(val2);
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 (arg1)->AutoSizeColLabelSize(arg2);
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 resultobj = SWIG_Py_Void();
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15981 PyObject *resultobj = 0;
15982 wxGrid *arg1 = (wxGrid *) 0 ;
15983 int arg2 ;
15984 int arg3 ;
15985 void *argp1 = 0 ;
15986 int res1 = 0 ;
15987 int val2 ;
15988 int ecode2 = 0 ;
15989 int val3 ;
15990 int ecode3 = 0 ;
15991 PyObject * obj0 = 0 ;
15992 PyObject * obj1 = 0 ;
15993 PyObject * obj2 = 0 ;
15994 char * kwnames[] = {
15995 (char *) "self",(char *) "col",(char *) "width", NULL
15996 };
15997
15998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16002 }
16003 arg1 = reinterpret_cast< wxGrid * >(argp1);
16004 ecode2 = SWIG_AsVal_int(obj1, &val2);
16005 if (!SWIG_IsOK(ecode2)) {
16006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16007 }
16008 arg2 = static_cast< int >(val2);
16009 ecode3 = SWIG_AsVal_int(obj2, &val3);
16010 if (!SWIG_IsOK(ecode3)) {
16011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16012 }
16013 arg3 = static_cast< int >(val3);
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 (arg1)->SetColMinimalWidth(arg2,arg3);
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 resultobj = SWIG_Py_Void();
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj = 0;
16029 wxGrid *arg1 = (wxGrid *) 0 ;
16030 int arg2 ;
16031 int arg3 ;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 int val2 ;
16035 int ecode2 = 0 ;
16036 int val3 ;
16037 int ecode3 = 0 ;
16038 PyObject * obj0 = 0 ;
16039 PyObject * obj1 = 0 ;
16040 PyObject * obj2 = 0 ;
16041 char * kwnames[] = {
16042 (char *) "self",(char *) "row",(char *) "width", NULL
16043 };
16044
16045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16049 }
16050 arg1 = reinterpret_cast< wxGrid * >(argp1);
16051 ecode2 = SWIG_AsVal_int(obj1, &val2);
16052 if (!SWIG_IsOK(ecode2)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16054 }
16055 arg2 = static_cast< int >(val2);
16056 ecode3 = SWIG_AsVal_int(obj2, &val3);
16057 if (!SWIG_IsOK(ecode3)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16059 }
16060 arg3 = static_cast< int >(val3);
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 (arg1)->SetRowMinimalHeight(arg2,arg3);
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_Py_Void();
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16075 PyObject *resultobj = 0;
16076 wxGrid *arg1 = (wxGrid *) 0 ;
16077 int arg2 ;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 int val2 ;
16081 int ecode2 = 0 ;
16082 PyObject * obj0 = 0 ;
16083 PyObject * obj1 = 0 ;
16084 char * kwnames[] = {
16085 (char *) "self",(char *) "width", NULL
16086 };
16087
16088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16090 if (!SWIG_IsOK(res1)) {
16091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16092 }
16093 arg1 = reinterpret_cast< wxGrid * >(argp1);
16094 ecode2 = SWIG_AsVal_int(obj1, &val2);
16095 if (!SWIG_IsOK(ecode2)) {
16096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16097 }
16098 arg2 = static_cast< int >(val2);
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 (arg1)->SetColMinimalAcceptableWidth(arg2);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_Py_Void();
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxGrid *arg1 = (wxGrid *) 0 ;
16115 int arg2 ;
16116 void *argp1 = 0 ;
16117 int res1 = 0 ;
16118 int val2 ;
16119 int ecode2 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "width", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16130 }
16131 arg1 = reinterpret_cast< wxGrid * >(argp1);
16132 ecode2 = SWIG_AsVal_int(obj1, &val2);
16133 if (!SWIG_IsOK(ecode2)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16135 }
16136 arg2 = static_cast< int >(val2);
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 resultobj = SWIG_Py_Void();
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16151 PyObject *resultobj = 0;
16152 wxGrid *arg1 = (wxGrid *) 0 ;
16153 int result;
16154 void *argp1 = 0 ;
16155 int res1 = 0 ;
16156 PyObject *swig_obj[1] ;
16157
16158 if (!args) SWIG_fail;
16159 swig_obj[0] = args;
16160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16163 }
16164 arg1 = reinterpret_cast< wxGrid * >(argp1);
16165 {
16166 PyThreadState* __tstate = wxPyBeginAllowThreads();
16167 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16168 wxPyEndAllowThreads(__tstate);
16169 if (PyErr_Occurred()) SWIG_fail;
16170 }
16171 resultobj = SWIG_From_int(static_cast< int >(result));
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16179 PyObject *resultobj = 0;
16180 wxGrid *arg1 = (wxGrid *) 0 ;
16181 int result;
16182 void *argp1 = 0 ;
16183 int res1 = 0 ;
16184 PyObject *swig_obj[1] ;
16185
16186 if (!args) SWIG_fail;
16187 swig_obj[0] = args;
16188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16189 if (!SWIG_IsOK(res1)) {
16190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16191 }
16192 arg1 = reinterpret_cast< wxGrid * >(argp1);
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 resultobj = SWIG_From_int(static_cast< int >(result));
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16207 PyObject *resultobj = 0;
16208 wxGrid *arg1 = (wxGrid *) 0 ;
16209 wxColour *arg2 = 0 ;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 wxColour temp2 ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *)"arg2", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16223 }
16224 arg1 = reinterpret_cast< wxGrid * >(argp1);
16225 {
16226 arg2 = &temp2;
16227 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16228 }
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16232 wxPyEndAllowThreads(__tstate);
16233 if (PyErr_Occurred()) SWIG_fail;
16234 }
16235 resultobj = SWIG_Py_Void();
16236 return resultobj;
16237 fail:
16238 return NULL;
16239 }
16240
16241
16242 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj = 0;
16244 wxGrid *arg1 = (wxGrid *) 0 ;
16245 int arg2 ;
16246 int arg3 ;
16247 wxColour *arg4 = 0 ;
16248 void *argp1 = 0 ;
16249 int res1 = 0 ;
16250 int val2 ;
16251 int ecode2 = 0 ;
16252 int val3 ;
16253 int ecode3 = 0 ;
16254 wxColour temp4 ;
16255 PyObject * obj0 = 0 ;
16256 PyObject * obj1 = 0 ;
16257 PyObject * obj2 = 0 ;
16258 PyObject * obj3 = 0 ;
16259 char * kwnames[] = {
16260 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16261 };
16262
16263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16265 if (!SWIG_IsOK(res1)) {
16266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16267 }
16268 arg1 = reinterpret_cast< wxGrid * >(argp1);
16269 ecode2 = SWIG_AsVal_int(obj1, &val2);
16270 if (!SWIG_IsOK(ecode2)) {
16271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16272 }
16273 arg2 = static_cast< int >(val2);
16274 ecode3 = SWIG_AsVal_int(obj2, &val3);
16275 if (!SWIG_IsOK(ecode3)) {
16276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16277 }
16278 arg3 = static_cast< int >(val3);
16279 {
16280 arg4 = &temp4;
16281 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16282 }
16283 {
16284 PyThreadState* __tstate = wxPyBeginAllowThreads();
16285 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16286 wxPyEndAllowThreads(__tstate);
16287 if (PyErr_Occurred()) SWIG_fail;
16288 }
16289 resultobj = SWIG_Py_Void();
16290 return resultobj;
16291 fail:
16292 return NULL;
16293 }
16294
16295
16296 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16297 PyObject *resultobj = 0;
16298 wxGrid *arg1 = (wxGrid *) 0 ;
16299 wxColour *arg2 = 0 ;
16300 void *argp1 = 0 ;
16301 int res1 = 0 ;
16302 wxColour temp2 ;
16303 PyObject * obj0 = 0 ;
16304 PyObject * obj1 = 0 ;
16305 char * kwnames[] = {
16306 (char *) "self",(char *)"arg2", NULL
16307 };
16308
16309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16311 if (!SWIG_IsOK(res1)) {
16312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16313 }
16314 arg1 = reinterpret_cast< wxGrid * >(argp1);
16315 {
16316 arg2 = &temp2;
16317 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16318 }
16319 {
16320 PyThreadState* __tstate = wxPyBeginAllowThreads();
16321 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 resultobj = SWIG_Py_Void();
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxGrid *arg1 = (wxGrid *) 0 ;
16335 int arg2 ;
16336 int arg3 ;
16337 wxColour *arg4 = 0 ;
16338 void *argp1 = 0 ;
16339 int res1 = 0 ;
16340 int val2 ;
16341 int ecode2 = 0 ;
16342 int val3 ;
16343 int ecode3 = 0 ;
16344 wxColour temp4 ;
16345 PyObject * obj0 = 0 ;
16346 PyObject * obj1 = 0 ;
16347 PyObject * obj2 = 0 ;
16348 PyObject * obj3 = 0 ;
16349 char * kwnames[] = {
16350 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16351 };
16352
16353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16357 }
16358 arg1 = reinterpret_cast< wxGrid * >(argp1);
16359 ecode2 = SWIG_AsVal_int(obj1, &val2);
16360 if (!SWIG_IsOK(ecode2)) {
16361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16362 }
16363 arg2 = static_cast< int >(val2);
16364 ecode3 = SWIG_AsVal_int(obj2, &val3);
16365 if (!SWIG_IsOK(ecode3)) {
16366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16367 }
16368 arg3 = static_cast< int >(val3);
16369 {
16370 arg4 = &temp4;
16371 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16372 }
16373 {
16374 PyThreadState* __tstate = wxPyBeginAllowThreads();
16375 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 resultobj = SWIG_Py_Void();
16380 return resultobj;
16381 fail:
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxGrid *arg1 = (wxGrid *) 0 ;
16389 wxFont *arg2 = 0 ;
16390 void *argp1 = 0 ;
16391 int res1 = 0 ;
16392 void *argp2 = 0 ;
16393 int res2 = 0 ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *)"arg2", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16404 }
16405 arg1 = reinterpret_cast< wxGrid * >(argp1);
16406 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16407 if (!SWIG_IsOK(res2)) {
16408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16409 }
16410 if (!argp2) {
16411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16412 }
16413 arg2 = reinterpret_cast< wxFont * >(argp2);
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 resultobj = SWIG_Py_Void();
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj = 0;
16429 wxGrid *arg1 = (wxGrid *) 0 ;
16430 int arg2 ;
16431 int arg3 ;
16432 wxFont *arg4 = 0 ;
16433 void *argp1 = 0 ;
16434 int res1 = 0 ;
16435 int val2 ;
16436 int ecode2 = 0 ;
16437 int val3 ;
16438 int ecode3 = 0 ;
16439 void *argp4 = 0 ;
16440 int res4 = 0 ;
16441 PyObject * obj0 = 0 ;
16442 PyObject * obj1 = 0 ;
16443 PyObject * obj2 = 0 ;
16444 PyObject * obj3 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16453 }
16454 arg1 = reinterpret_cast< wxGrid * >(argp1);
16455 ecode2 = SWIG_AsVal_int(obj1, &val2);
16456 if (!SWIG_IsOK(ecode2)) {
16457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16458 }
16459 arg2 = static_cast< int >(val2);
16460 ecode3 = SWIG_AsVal_int(obj2, &val3);
16461 if (!SWIG_IsOK(ecode3)) {
16462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16463 }
16464 arg3 = static_cast< int >(val3);
16465 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16466 if (!SWIG_IsOK(res4)) {
16467 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16468 }
16469 if (!argp4) {
16470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16471 }
16472 arg4 = reinterpret_cast< wxFont * >(argp4);
16473 {
16474 PyThreadState* __tstate = wxPyBeginAllowThreads();
16475 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_Py_Void();
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj = 0;
16488 wxGrid *arg1 = (wxGrid *) 0 ;
16489 int arg2 ;
16490 int arg3 ;
16491 void *argp1 = 0 ;
16492 int res1 = 0 ;
16493 int val2 ;
16494 int ecode2 = 0 ;
16495 int val3 ;
16496 int ecode3 = 0 ;
16497 PyObject * obj0 = 0 ;
16498 PyObject * obj1 = 0 ;
16499 PyObject * obj2 = 0 ;
16500 char * kwnames[] = {
16501 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16502 };
16503
16504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16508 }
16509 arg1 = reinterpret_cast< wxGrid * >(argp1);
16510 ecode2 = SWIG_AsVal_int(obj1, &val2);
16511 if (!SWIG_IsOK(ecode2)) {
16512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16513 }
16514 arg2 = static_cast< int >(val2);
16515 ecode3 = SWIG_AsVal_int(obj2, &val3);
16516 if (!SWIG_IsOK(ecode3)) {
16517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16518 }
16519 arg3 = static_cast< int >(val3);
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 resultobj = SWIG_Py_Void();
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxGrid *arg1 = (wxGrid *) 0 ;
16536 int arg2 ;
16537 int arg3 ;
16538 int arg4 ;
16539 int arg5 ;
16540 void *argp1 = 0 ;
16541 int res1 = 0 ;
16542 int val2 ;
16543 int ecode2 = 0 ;
16544 int val3 ;
16545 int ecode3 = 0 ;
16546 int val4 ;
16547 int ecode4 = 0 ;
16548 int val5 ;
16549 int ecode5 = 0 ;
16550 PyObject * obj0 = 0 ;
16551 PyObject * obj1 = 0 ;
16552 PyObject * obj2 = 0 ;
16553 PyObject * obj3 = 0 ;
16554 PyObject * obj4 = 0 ;
16555 char * kwnames[] = {
16556 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16557 };
16558
16559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16561 if (!SWIG_IsOK(res1)) {
16562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16563 }
16564 arg1 = reinterpret_cast< wxGrid * >(argp1);
16565 ecode2 = SWIG_AsVal_int(obj1, &val2);
16566 if (!SWIG_IsOK(ecode2)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16568 }
16569 arg2 = static_cast< int >(val2);
16570 ecode3 = SWIG_AsVal_int(obj2, &val3);
16571 if (!SWIG_IsOK(ecode3)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16573 }
16574 arg3 = static_cast< int >(val3);
16575 ecode4 = SWIG_AsVal_int(obj3, &val4);
16576 if (!SWIG_IsOK(ecode4)) {
16577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16578 }
16579 arg4 = static_cast< int >(val4);
16580 ecode5 = SWIG_AsVal_int(obj4, &val5);
16581 if (!SWIG_IsOK(ecode5)) {
16582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16583 }
16584 arg5 = static_cast< int >(val5);
16585 {
16586 PyThreadState* __tstate = wxPyBeginAllowThreads();
16587 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16588 wxPyEndAllowThreads(__tstate);
16589 if (PyErr_Occurred()) SWIG_fail;
16590 }
16591 resultobj = SWIG_Py_Void();
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj = 0;
16600 wxGrid *arg1 = (wxGrid *) 0 ;
16601 bool arg2 ;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 bool val2 ;
16605 int ecode2 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "allow", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16616 }
16617 arg1 = reinterpret_cast< wxGrid * >(argp1);
16618 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16619 if (!SWIG_IsOK(ecode2)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16621 }
16622 arg2 = static_cast< bool >(val2);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->SetDefaultCellOverflow(arg2);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_Py_Void();
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj = 0;
16638 wxGrid *arg1 = (wxGrid *) 0 ;
16639 int arg2 ;
16640 int arg3 ;
16641 bool arg4 ;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 int val2 ;
16645 int ecode2 = 0 ;
16646 int val3 ;
16647 int ecode3 = 0 ;
16648 bool val4 ;
16649 int ecode4 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 PyObject * obj1 = 0 ;
16652 PyObject * obj2 = 0 ;
16653 PyObject * obj3 = 0 ;
16654 char * kwnames[] = {
16655 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16656 };
16657
16658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16660 if (!SWIG_IsOK(res1)) {
16661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16662 }
16663 arg1 = reinterpret_cast< wxGrid * >(argp1);
16664 ecode2 = SWIG_AsVal_int(obj1, &val2);
16665 if (!SWIG_IsOK(ecode2)) {
16666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16667 }
16668 arg2 = static_cast< int >(val2);
16669 ecode3 = SWIG_AsVal_int(obj2, &val3);
16670 if (!SWIG_IsOK(ecode3)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16672 }
16673 arg3 = static_cast< int >(val3);
16674 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16675 if (!SWIG_IsOK(ecode4)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16677 }
16678 arg4 = static_cast< bool >(val4);
16679 {
16680 PyThreadState* __tstate = wxPyBeginAllowThreads();
16681 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 resultobj = SWIG_Py_Void();
16686 return resultobj;
16687 fail:
16688 return NULL;
16689 }
16690
16691
16692 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16693 PyObject *resultobj = 0;
16694 wxGrid *arg1 = (wxGrid *) 0 ;
16695 int arg2 ;
16696 int arg3 ;
16697 int arg4 ;
16698 int arg5 ;
16699 void *argp1 = 0 ;
16700 int res1 = 0 ;
16701 int val2 ;
16702 int ecode2 = 0 ;
16703 int val3 ;
16704 int ecode3 = 0 ;
16705 int val4 ;
16706 int ecode4 = 0 ;
16707 int val5 ;
16708 int ecode5 = 0 ;
16709 PyObject * obj0 = 0 ;
16710 PyObject * obj1 = 0 ;
16711 PyObject * obj2 = 0 ;
16712 PyObject * obj3 = 0 ;
16713 PyObject * obj4 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16722 }
16723 arg1 = reinterpret_cast< wxGrid * >(argp1);
16724 ecode2 = SWIG_AsVal_int(obj1, &val2);
16725 if (!SWIG_IsOK(ecode2)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16727 }
16728 arg2 = static_cast< int >(val2);
16729 ecode3 = SWIG_AsVal_int(obj2, &val3);
16730 if (!SWIG_IsOK(ecode3)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16732 }
16733 arg3 = static_cast< int >(val3);
16734 ecode4 = SWIG_AsVal_int(obj3, &val4);
16735 if (!SWIG_IsOK(ecode4)) {
16736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16737 }
16738 arg4 = static_cast< int >(val4);
16739 ecode5 = SWIG_AsVal_int(obj4, &val5);
16740 if (!SWIG_IsOK(ecode5)) {
16741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16742 }
16743 arg5 = static_cast< int >(val5);
16744 {
16745 PyThreadState* __tstate = wxPyBeginAllowThreads();
16746 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 resultobj = SWIG_Py_Void();
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj = 0;
16759 wxGrid *arg1 = (wxGrid *) 0 ;
16760 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16761 void *argp1 = 0 ;
16762 int res1 = 0 ;
16763 void *argp2 = 0 ;
16764 int res2 = 0 ;
16765 PyObject * obj0 = 0 ;
16766 PyObject * obj1 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "self",(char *) "renderer", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16775 }
16776 arg1 = reinterpret_cast< wxGrid * >(argp1);
16777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16778 if (!SWIG_IsOK(res2)) {
16779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16780 }
16781 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16782 {
16783 PyThreadState* __tstate = wxPyBeginAllowThreads();
16784 (arg1)->SetDefaultRenderer(arg2);
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 resultobj = SWIG_Py_Void();
16789 return resultobj;
16790 fail:
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxGrid *arg1 = (wxGrid *) 0 ;
16798 int arg2 ;
16799 int arg3 ;
16800 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 int val2 ;
16804 int ecode2 = 0 ;
16805 int val3 ;
16806 int ecode3 = 0 ;
16807 void *argp4 = 0 ;
16808 int res4 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 PyObject * obj2 = 0 ;
16812 PyObject * obj3 = 0 ;
16813 char * kwnames[] = {
16814 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16815 };
16816
16817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16819 if (!SWIG_IsOK(res1)) {
16820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16821 }
16822 arg1 = reinterpret_cast< wxGrid * >(argp1);
16823 ecode2 = SWIG_AsVal_int(obj1, &val2);
16824 if (!SWIG_IsOK(ecode2)) {
16825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16826 }
16827 arg2 = static_cast< int >(val2);
16828 ecode3 = SWIG_AsVal_int(obj2, &val3);
16829 if (!SWIG_IsOK(ecode3)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16831 }
16832 arg3 = static_cast< int >(val3);
16833 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16834 if (!SWIG_IsOK(res4)) {
16835 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16836 }
16837 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16852 PyObject *resultobj = 0;
16853 wxGrid *arg1 = (wxGrid *) 0 ;
16854 wxGridCellRenderer *result = 0 ;
16855 void *argp1 = 0 ;
16856 int res1 = 0 ;
16857 PyObject *swig_obj[1] ;
16858
16859 if (!args) SWIG_fail;
16860 swig_obj[0] = args;
16861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16862 if (!SWIG_IsOK(res1)) {
16863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16864 }
16865 arg1 = reinterpret_cast< wxGrid * >(argp1);
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16869 wxPyEndAllowThreads(__tstate);
16870 if (PyErr_Occurred()) SWIG_fail;
16871 }
16872 {
16873 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16874 }
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj = 0;
16883 wxGrid *arg1 = (wxGrid *) 0 ;
16884 int arg2 ;
16885 int arg3 ;
16886 wxGridCellRenderer *result = 0 ;
16887 void *argp1 = 0 ;
16888 int res1 = 0 ;
16889 int val2 ;
16890 int ecode2 = 0 ;
16891 int val3 ;
16892 int ecode3 = 0 ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 PyObject * obj2 = 0 ;
16896 char * kwnames[] = {
16897 (char *) "self",(char *) "row",(char *) "col", NULL
16898 };
16899
16900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16902 if (!SWIG_IsOK(res1)) {
16903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16904 }
16905 arg1 = reinterpret_cast< wxGrid * >(argp1);
16906 ecode2 = SWIG_AsVal_int(obj1, &val2);
16907 if (!SWIG_IsOK(ecode2)) {
16908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16909 }
16910 arg2 = static_cast< int >(val2);
16911 ecode3 = SWIG_AsVal_int(obj2, &val3);
16912 if (!SWIG_IsOK(ecode3)) {
16913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16914 }
16915 arg3 = static_cast< int >(val3);
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 {
16923 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16924 }
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxGrid *arg1 = (wxGrid *) 0 ;
16934 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16935 void *argp1 = 0 ;
16936 int res1 = 0 ;
16937 void *argp2 = 0 ;
16938 int res2 = 0 ;
16939 PyObject * obj0 = 0 ;
16940 PyObject * obj1 = 0 ;
16941 char * kwnames[] = {
16942 (char *) "self",(char *) "editor", NULL
16943 };
16944
16945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16947 if (!SWIG_IsOK(res1)) {
16948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16949 }
16950 arg1 = reinterpret_cast< wxGrid * >(argp1);
16951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16952 if (!SWIG_IsOK(res2)) {
16953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16954 }
16955 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 (arg1)->SetDefaultEditor(arg2);
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_Py_Void();
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj = 0;
16971 wxGrid *arg1 = (wxGrid *) 0 ;
16972 int arg2 ;
16973 int arg3 ;
16974 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 int val2 ;
16978 int ecode2 = 0 ;
16979 int val3 ;
16980 int ecode3 = 0 ;
16981 void *argp4 = 0 ;
16982 int res4 = 0 ;
16983 PyObject * obj0 = 0 ;
16984 PyObject * obj1 = 0 ;
16985 PyObject * obj2 = 0 ;
16986 PyObject * obj3 = 0 ;
16987 char * kwnames[] = {
16988 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16989 };
16990
16991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16993 if (!SWIG_IsOK(res1)) {
16994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16995 }
16996 arg1 = reinterpret_cast< wxGrid * >(argp1);
16997 ecode2 = SWIG_AsVal_int(obj1, &val2);
16998 if (!SWIG_IsOK(ecode2)) {
16999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17000 }
17001 arg2 = static_cast< int >(val2);
17002 ecode3 = SWIG_AsVal_int(obj2, &val3);
17003 if (!SWIG_IsOK(ecode3)) {
17004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17005 }
17006 arg3 = static_cast< int >(val3);
17007 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17008 if (!SWIG_IsOK(res4)) {
17009 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17010 }
17011 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 (arg1)->SetCellEditor(arg2,arg3,arg4);
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = SWIG_Py_Void();
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17026 PyObject *resultobj = 0;
17027 wxGrid *arg1 = (wxGrid *) 0 ;
17028 wxGridCellEditor *result = 0 ;
17029 void *argp1 = 0 ;
17030 int res1 = 0 ;
17031 PyObject *swig_obj[1] ;
17032
17033 if (!args) SWIG_fail;
17034 swig_obj[0] = args;
17035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17038 }
17039 arg1 = reinterpret_cast< wxGrid * >(argp1);
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 {
17047 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17048 }
17049 return resultobj;
17050 fail:
17051 return NULL;
17052 }
17053
17054
17055 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17056 PyObject *resultobj = 0;
17057 wxGrid *arg1 = (wxGrid *) 0 ;
17058 int arg2 ;
17059 int arg3 ;
17060 wxGridCellEditor *result = 0 ;
17061 void *argp1 = 0 ;
17062 int res1 = 0 ;
17063 int val2 ;
17064 int ecode2 = 0 ;
17065 int val3 ;
17066 int ecode3 = 0 ;
17067 PyObject * obj0 = 0 ;
17068 PyObject * obj1 = 0 ;
17069 PyObject * obj2 = 0 ;
17070 char * kwnames[] = {
17071 (char *) "self",(char *) "row",(char *) "col", NULL
17072 };
17073
17074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17076 if (!SWIG_IsOK(res1)) {
17077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17078 }
17079 arg1 = reinterpret_cast< wxGrid * >(argp1);
17080 ecode2 = SWIG_AsVal_int(obj1, &val2);
17081 if (!SWIG_IsOK(ecode2)) {
17082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17083 }
17084 arg2 = static_cast< int >(val2);
17085 ecode3 = SWIG_AsVal_int(obj2, &val3);
17086 if (!SWIG_IsOK(ecode3)) {
17087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17088 }
17089 arg3 = static_cast< int >(val3);
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 {
17097 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17098 }
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj = 0;
17107 wxGrid *arg1 = (wxGrid *) 0 ;
17108 int arg2 ;
17109 int arg3 ;
17110 wxString result;
17111 void *argp1 = 0 ;
17112 int res1 = 0 ;
17113 int val2 ;
17114 int ecode2 = 0 ;
17115 int val3 ;
17116 int ecode3 = 0 ;
17117 PyObject * obj0 = 0 ;
17118 PyObject * obj1 = 0 ;
17119 PyObject * obj2 = 0 ;
17120 char * kwnames[] = {
17121 (char *) "self",(char *) "row",(char *) "col", NULL
17122 };
17123
17124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17126 if (!SWIG_IsOK(res1)) {
17127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17128 }
17129 arg1 = reinterpret_cast< wxGrid * >(argp1);
17130 ecode2 = SWIG_AsVal_int(obj1, &val2);
17131 if (!SWIG_IsOK(ecode2)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17133 }
17134 arg2 = static_cast< int >(val2);
17135 ecode3 = SWIG_AsVal_int(obj2, &val3);
17136 if (!SWIG_IsOK(ecode3)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17138 }
17139 arg3 = static_cast< int >(val3);
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (arg1)->GetCellValue(arg2,arg3);
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 {
17147 #if wxUSE_UNICODE
17148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17149 #else
17150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17151 #endif
17152 }
17153 return resultobj;
17154 fail:
17155 return NULL;
17156 }
17157
17158
17159 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17160 PyObject *resultobj = 0;
17161 wxGrid *arg1 = (wxGrid *) 0 ;
17162 int arg2 ;
17163 int arg3 ;
17164 wxString *arg4 = 0 ;
17165 void *argp1 = 0 ;
17166 int res1 = 0 ;
17167 int val2 ;
17168 int ecode2 = 0 ;
17169 int val3 ;
17170 int ecode3 = 0 ;
17171 bool temp4 = false ;
17172 PyObject * obj0 = 0 ;
17173 PyObject * obj1 = 0 ;
17174 PyObject * obj2 = 0 ;
17175 PyObject * obj3 = 0 ;
17176 char * kwnames[] = {
17177 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17178 };
17179
17180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17182 if (!SWIG_IsOK(res1)) {
17183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17184 }
17185 arg1 = reinterpret_cast< wxGrid * >(argp1);
17186 ecode2 = SWIG_AsVal_int(obj1, &val2);
17187 if (!SWIG_IsOK(ecode2)) {
17188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17189 }
17190 arg2 = static_cast< int >(val2);
17191 ecode3 = SWIG_AsVal_int(obj2, &val3);
17192 if (!SWIG_IsOK(ecode3)) {
17193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17194 }
17195 arg3 = static_cast< int >(val3);
17196 {
17197 arg4 = wxString_in_helper(obj3);
17198 if (arg4 == NULL) SWIG_fail;
17199 temp4 = true;
17200 }
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 resultobj = SWIG_Py_Void();
17208 {
17209 if (temp4)
17210 delete arg4;
17211 }
17212 return resultobj;
17213 fail:
17214 {
17215 if (temp4)
17216 delete arg4;
17217 }
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj = 0;
17224 wxGrid *arg1 = (wxGrid *) 0 ;
17225 int arg2 ;
17226 int arg3 ;
17227 bool result;
17228 void *argp1 = 0 ;
17229 int res1 = 0 ;
17230 int val2 ;
17231 int ecode2 = 0 ;
17232 int val3 ;
17233 int ecode3 = 0 ;
17234 PyObject * obj0 = 0 ;
17235 PyObject * obj1 = 0 ;
17236 PyObject * obj2 = 0 ;
17237 char * kwnames[] = {
17238 (char *) "self",(char *) "row",(char *) "col", NULL
17239 };
17240
17241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17245 }
17246 arg1 = reinterpret_cast< wxGrid * >(argp1);
17247 ecode2 = SWIG_AsVal_int(obj1, &val2);
17248 if (!SWIG_IsOK(ecode2)) {
17249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17250 }
17251 arg2 = static_cast< int >(val2);
17252 ecode3 = SWIG_AsVal_int(obj2, &val3);
17253 if (!SWIG_IsOK(ecode3)) {
17254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17255 }
17256 arg3 = static_cast< int >(val3);
17257 {
17258 PyThreadState* __tstate = wxPyBeginAllowThreads();
17259 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17260 wxPyEndAllowThreads(__tstate);
17261 if (PyErr_Occurred()) SWIG_fail;
17262 }
17263 {
17264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17265 }
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17273 PyObject *resultobj = 0;
17274 wxGrid *arg1 = (wxGrid *) 0 ;
17275 int arg2 ;
17276 int arg3 ;
17277 bool arg4 = (bool) true ;
17278 void *argp1 = 0 ;
17279 int res1 = 0 ;
17280 int val2 ;
17281 int ecode2 = 0 ;
17282 int val3 ;
17283 int ecode3 = 0 ;
17284 bool val4 ;
17285 int ecode4 = 0 ;
17286 PyObject * obj0 = 0 ;
17287 PyObject * obj1 = 0 ;
17288 PyObject * obj2 = 0 ;
17289 PyObject * obj3 = 0 ;
17290 char * kwnames[] = {
17291 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17292 };
17293
17294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17296 if (!SWIG_IsOK(res1)) {
17297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17298 }
17299 arg1 = reinterpret_cast< wxGrid * >(argp1);
17300 ecode2 = SWIG_AsVal_int(obj1, &val2);
17301 if (!SWIG_IsOK(ecode2)) {
17302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17303 }
17304 arg2 = static_cast< int >(val2);
17305 ecode3 = SWIG_AsVal_int(obj2, &val3);
17306 if (!SWIG_IsOK(ecode3)) {
17307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17308 }
17309 arg3 = static_cast< int >(val3);
17310 if (obj3) {
17311 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17312 if (!SWIG_IsOK(ecode4)) {
17313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17314 }
17315 arg4 = static_cast< bool >(val4);
17316 }
17317 {
17318 PyThreadState* __tstate = wxPyBeginAllowThreads();
17319 (arg1)->SetReadOnly(arg2,arg3,arg4);
17320 wxPyEndAllowThreads(__tstate);
17321 if (PyErr_Occurred()) SWIG_fail;
17322 }
17323 resultobj = SWIG_Py_Void();
17324 return resultobj;
17325 fail:
17326 return NULL;
17327 }
17328
17329
17330 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17331 PyObject *resultobj = 0;
17332 wxGrid *arg1 = (wxGrid *) 0 ;
17333 int arg2 ;
17334 bool arg3 = (bool) false ;
17335 void *argp1 = 0 ;
17336 int res1 = 0 ;
17337 int val2 ;
17338 int ecode2 = 0 ;
17339 bool val3 ;
17340 int ecode3 = 0 ;
17341 PyObject * obj0 = 0 ;
17342 PyObject * obj1 = 0 ;
17343 PyObject * obj2 = 0 ;
17344 char * kwnames[] = {
17345 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17346 };
17347
17348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17350 if (!SWIG_IsOK(res1)) {
17351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17352 }
17353 arg1 = reinterpret_cast< wxGrid * >(argp1);
17354 ecode2 = SWIG_AsVal_int(obj1, &val2);
17355 if (!SWIG_IsOK(ecode2)) {
17356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17357 }
17358 arg2 = static_cast< int >(val2);
17359 if (obj2) {
17360 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17361 if (!SWIG_IsOK(ecode3)) {
17362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17363 }
17364 arg3 = static_cast< bool >(val3);
17365 }
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 (arg1)->SelectRow(arg2,arg3);
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 resultobj = SWIG_Py_Void();
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj = 0;
17381 wxGrid *arg1 = (wxGrid *) 0 ;
17382 int arg2 ;
17383 bool arg3 = (bool) false ;
17384 void *argp1 = 0 ;
17385 int res1 = 0 ;
17386 int val2 ;
17387 int ecode2 = 0 ;
17388 bool val3 ;
17389 int ecode3 = 0 ;
17390 PyObject * obj0 = 0 ;
17391 PyObject * obj1 = 0 ;
17392 PyObject * obj2 = 0 ;
17393 char * kwnames[] = {
17394 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17395 };
17396
17397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17399 if (!SWIG_IsOK(res1)) {
17400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17401 }
17402 arg1 = reinterpret_cast< wxGrid * >(argp1);
17403 ecode2 = SWIG_AsVal_int(obj1, &val2);
17404 if (!SWIG_IsOK(ecode2)) {
17405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17406 }
17407 arg2 = static_cast< int >(val2);
17408 if (obj2) {
17409 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17410 if (!SWIG_IsOK(ecode3)) {
17411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17412 }
17413 arg3 = static_cast< bool >(val3);
17414 }
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 (arg1)->SelectCol(arg2,arg3);
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_Py_Void();
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj = 0;
17430 wxGrid *arg1 = (wxGrid *) 0 ;
17431 int arg2 ;
17432 int arg3 ;
17433 int arg4 ;
17434 int arg5 ;
17435 bool arg6 = (bool) false ;
17436 void *argp1 = 0 ;
17437 int res1 = 0 ;
17438 int val2 ;
17439 int ecode2 = 0 ;
17440 int val3 ;
17441 int ecode3 = 0 ;
17442 int val4 ;
17443 int ecode4 = 0 ;
17444 int val5 ;
17445 int ecode5 = 0 ;
17446 bool val6 ;
17447 int ecode6 = 0 ;
17448 PyObject * obj0 = 0 ;
17449 PyObject * obj1 = 0 ;
17450 PyObject * obj2 = 0 ;
17451 PyObject * obj3 = 0 ;
17452 PyObject * obj4 = 0 ;
17453 PyObject * obj5 = 0 ;
17454 char * kwnames[] = {
17455 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17456 };
17457
17458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17460 if (!SWIG_IsOK(res1)) {
17461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17462 }
17463 arg1 = reinterpret_cast< wxGrid * >(argp1);
17464 ecode2 = SWIG_AsVal_int(obj1, &val2);
17465 if (!SWIG_IsOK(ecode2)) {
17466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17467 }
17468 arg2 = static_cast< int >(val2);
17469 ecode3 = SWIG_AsVal_int(obj2, &val3);
17470 if (!SWIG_IsOK(ecode3)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17472 }
17473 arg3 = static_cast< int >(val3);
17474 ecode4 = SWIG_AsVal_int(obj3, &val4);
17475 if (!SWIG_IsOK(ecode4)) {
17476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17477 }
17478 arg4 = static_cast< int >(val4);
17479 ecode5 = SWIG_AsVal_int(obj4, &val5);
17480 if (!SWIG_IsOK(ecode5)) {
17481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17482 }
17483 arg5 = static_cast< int >(val5);
17484 if (obj5) {
17485 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17486 if (!SWIG_IsOK(ecode6)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17488 }
17489 arg6 = static_cast< bool >(val6);
17490 }
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 resultobj = SWIG_Py_Void();
17498 return resultobj;
17499 fail:
17500 return NULL;
17501 }
17502
17503
17504 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *resultobj = 0;
17506 wxGrid *arg1 = (wxGrid *) 0 ;
17507 void *argp1 = 0 ;
17508 int res1 = 0 ;
17509 PyObject *swig_obj[1] ;
17510
17511 if (!args) SWIG_fail;
17512 swig_obj[0] = args;
17513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17514 if (!SWIG_IsOK(res1)) {
17515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17516 }
17517 arg1 = reinterpret_cast< wxGrid * >(argp1);
17518 {
17519 PyThreadState* __tstate = wxPyBeginAllowThreads();
17520 (arg1)->SelectAll();
17521 wxPyEndAllowThreads(__tstate);
17522 if (PyErr_Occurred()) SWIG_fail;
17523 }
17524 resultobj = SWIG_Py_Void();
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxGrid *arg1 = (wxGrid *) 0 ;
17534 bool result;
17535 void *argp1 = 0 ;
17536 int res1 = 0 ;
17537 PyObject *swig_obj[1] ;
17538
17539 if (!args) SWIG_fail;
17540 swig_obj[0] = args;
17541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17542 if (!SWIG_IsOK(res1)) {
17543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17544 }
17545 arg1 = reinterpret_cast< wxGrid * >(argp1);
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (bool)(arg1)->IsSelection();
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 {
17553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17554 }
17555 return resultobj;
17556 fail:
17557 return NULL;
17558 }
17559
17560
17561 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17562 PyObject *resultobj = 0;
17563 wxGrid *arg1 = (wxGrid *) 0 ;
17564 void *argp1 = 0 ;
17565 int res1 = 0 ;
17566 PyObject *swig_obj[1] ;
17567
17568 if (!args) SWIG_fail;
17569 swig_obj[0] = args;
17570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17571 if (!SWIG_IsOK(res1)) {
17572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17573 }
17574 arg1 = reinterpret_cast< wxGrid * >(argp1);
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 (arg1)->ClearSelection();
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 resultobj = SWIG_Py_Void();
17582 return resultobj;
17583 fail:
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17589 PyObject *resultobj = 0;
17590 wxGrid *arg1 = (wxGrid *) 0 ;
17591 int arg2 ;
17592 int arg3 ;
17593 bool result;
17594 void *argp1 = 0 ;
17595 int res1 = 0 ;
17596 int val2 ;
17597 int ecode2 = 0 ;
17598 int val3 ;
17599 int ecode3 = 0 ;
17600 PyObject * obj0 = 0 ;
17601 PyObject * obj1 = 0 ;
17602 PyObject * obj2 = 0 ;
17603 char * kwnames[] = {
17604 (char *) "self",(char *) "row",(char *) "col", NULL
17605 };
17606
17607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17611 }
17612 arg1 = reinterpret_cast< wxGrid * >(argp1);
17613 ecode2 = SWIG_AsVal_int(obj1, &val2);
17614 if (!SWIG_IsOK(ecode2)) {
17615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17616 }
17617 arg2 = static_cast< int >(val2);
17618 ecode3 = SWIG_AsVal_int(obj2, &val3);
17619 if (!SWIG_IsOK(ecode3)) {
17620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17621 }
17622 arg3 = static_cast< int >(val3);
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *resultobj = 0;
17640 wxGrid *arg1 = (wxGrid *) 0 ;
17641 wxGridCellCoordsArray result;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 PyObject *swig_obj[1] ;
17645
17646 if (!args) SWIG_fail;
17647 swig_obj[0] = args;
17648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17651 }
17652 arg1 = reinterpret_cast< wxGrid * >(argp1);
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 result = ((wxGrid const *)arg1)->GetSelectedCells();
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 resultobj = wxGridCellCoordsArray_helper(result);
17661 }
17662 return resultobj;
17663 fail:
17664 return NULL;
17665 }
17666
17667
17668 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17669 PyObject *resultobj = 0;
17670 wxGrid *arg1 = (wxGrid *) 0 ;
17671 wxGridCellCoordsArray result;
17672 void *argp1 = 0 ;
17673 int res1 = 0 ;
17674 PyObject *swig_obj[1] ;
17675
17676 if (!args) SWIG_fail;
17677 swig_obj[0] = args;
17678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17679 if (!SWIG_IsOK(res1)) {
17680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17681 }
17682 arg1 = reinterpret_cast< wxGrid * >(argp1);
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = wxGridCellCoordsArray_helper(result);
17691 }
17692 return resultobj;
17693 fail:
17694 return NULL;
17695 }
17696
17697
17698 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17699 PyObject *resultobj = 0;
17700 wxGrid *arg1 = (wxGrid *) 0 ;
17701 wxGridCellCoordsArray result;
17702 void *argp1 = 0 ;
17703 int res1 = 0 ;
17704 PyObject *swig_obj[1] ;
17705
17706 if (!args) SWIG_fail;
17707 swig_obj[0] = args;
17708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17711 }
17712 arg1 = reinterpret_cast< wxGrid * >(argp1);
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 {
17720 resultobj = wxGridCellCoordsArray_helper(result);
17721 }
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17729 PyObject *resultobj = 0;
17730 wxGrid *arg1 = (wxGrid *) 0 ;
17731 wxArrayInt result;
17732 void *argp1 = 0 ;
17733 int res1 = 0 ;
17734 PyObject *swig_obj[1] ;
17735
17736 if (!args) SWIG_fail;
17737 swig_obj[0] = args;
17738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17739 if (!SWIG_IsOK(res1)) {
17740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17741 }
17742 arg1 = reinterpret_cast< wxGrid * >(argp1);
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = ((wxGrid const *)arg1)->GetSelectedRows();
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = PyList_New(0);
17751 size_t idx;
17752 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17753 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17754 PyList_Append(resultobj, val);
17755 Py_DECREF(val);
17756 }
17757 }
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17765 PyObject *resultobj = 0;
17766 wxGrid *arg1 = (wxGrid *) 0 ;
17767 wxArrayInt result;
17768 void *argp1 = 0 ;
17769 int res1 = 0 ;
17770 PyObject *swig_obj[1] ;
17771
17772 if (!args) SWIG_fail;
17773 swig_obj[0] = args;
17774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17775 if (!SWIG_IsOK(res1)) {
17776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17777 }
17778 arg1 = reinterpret_cast< wxGrid * >(argp1);
17779 {
17780 PyThreadState* __tstate = wxPyBeginAllowThreads();
17781 result = ((wxGrid const *)arg1)->GetSelectedCols();
17782 wxPyEndAllowThreads(__tstate);
17783 if (PyErr_Occurred()) SWIG_fail;
17784 }
17785 {
17786 resultobj = PyList_New(0);
17787 size_t idx;
17788 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17789 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17790 PyList_Append(resultobj, val);
17791 Py_DECREF(val);
17792 }
17793 }
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj = 0;
17802 wxGrid *arg1 = (wxGrid *) 0 ;
17803 int arg2 ;
17804 void *argp1 = 0 ;
17805 int res1 = 0 ;
17806 int val2 ;
17807 int ecode2 = 0 ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 char * kwnames[] = {
17811 (char *) "self",(char *) "row", NULL
17812 };
17813
17814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17816 if (!SWIG_IsOK(res1)) {
17817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17818 }
17819 arg1 = reinterpret_cast< wxGrid * >(argp1);
17820 ecode2 = SWIG_AsVal_int(obj1, &val2);
17821 if (!SWIG_IsOK(ecode2)) {
17822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17823 }
17824 arg2 = static_cast< int >(val2);
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 (arg1)->DeselectRow(arg2);
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_Py_Void();
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17839 PyObject *resultobj = 0;
17840 wxGrid *arg1 = (wxGrid *) 0 ;
17841 int arg2 ;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 int val2 ;
17845 int ecode2 = 0 ;
17846 PyObject * obj0 = 0 ;
17847 PyObject * obj1 = 0 ;
17848 char * kwnames[] = {
17849 (char *) "self",(char *) "col", NULL
17850 };
17851
17852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17854 if (!SWIG_IsOK(res1)) {
17855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17856 }
17857 arg1 = reinterpret_cast< wxGrid * >(argp1);
17858 ecode2 = SWIG_AsVal_int(obj1, &val2);
17859 if (!SWIG_IsOK(ecode2)) {
17860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17861 }
17862 arg2 = static_cast< int >(val2);
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 (arg1)->DeselectCol(arg2);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 resultobj = SWIG_Py_Void();
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj = 0;
17878 wxGrid *arg1 = (wxGrid *) 0 ;
17879 int arg2 ;
17880 int arg3 ;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 int val2 ;
17884 int ecode2 = 0 ;
17885 int val3 ;
17886 int ecode3 = 0 ;
17887 PyObject * obj0 = 0 ;
17888 PyObject * obj1 = 0 ;
17889 PyObject * obj2 = 0 ;
17890 char * kwnames[] = {
17891 (char *) "self",(char *) "row",(char *) "col", NULL
17892 };
17893
17894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17896 if (!SWIG_IsOK(res1)) {
17897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17898 }
17899 arg1 = reinterpret_cast< wxGrid * >(argp1);
17900 ecode2 = SWIG_AsVal_int(obj1, &val2);
17901 if (!SWIG_IsOK(ecode2)) {
17902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17903 }
17904 arg2 = static_cast< int >(val2);
17905 ecode3 = SWIG_AsVal_int(obj2, &val3);
17906 if (!SWIG_IsOK(ecode3)) {
17907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17908 }
17909 arg3 = static_cast< int >(val3);
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 (arg1)->DeselectCell(arg2,arg3);
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 resultobj = SWIG_Py_Void();
17917 return resultobj;
17918 fail:
17919 return NULL;
17920 }
17921
17922
17923 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj = 0;
17925 wxGrid *arg1 = (wxGrid *) 0 ;
17926 wxGridCellCoords *arg2 = 0 ;
17927 wxGridCellCoords *arg3 = 0 ;
17928 wxRect result;
17929 void *argp1 = 0 ;
17930 int res1 = 0 ;
17931 wxGridCellCoords temp2 ;
17932 wxGridCellCoords temp3 ;
17933 PyObject * obj0 = 0 ;
17934 PyObject * obj1 = 0 ;
17935 PyObject * obj2 = 0 ;
17936 char * kwnames[] = {
17937 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17938 };
17939
17940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17942 if (!SWIG_IsOK(res1)) {
17943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17944 }
17945 arg1 = reinterpret_cast< wxGrid * >(argp1);
17946 {
17947 arg2 = &temp2;
17948 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17949 }
17950 {
17951 arg3 = &temp3;
17952 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17953 }
17954 {
17955 PyThreadState* __tstate = wxPyBeginAllowThreads();
17956 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17968 PyObject *resultobj = 0;
17969 wxGrid *arg1 = (wxGrid *) 0 ;
17970 wxColour result;
17971 void *argp1 = 0 ;
17972 int res1 = 0 ;
17973 PyObject *swig_obj[1] ;
17974
17975 if (!args) SWIG_fail;
17976 swig_obj[0] = args;
17977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17978 if (!SWIG_IsOK(res1)) {
17979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17980 }
17981 arg1 = reinterpret_cast< wxGrid * >(argp1);
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *resultobj = 0;
17997 wxGrid *arg1 = (wxGrid *) 0 ;
17998 wxColour result;
17999 void *argp1 = 0 ;
18000 int res1 = 0 ;
18001 PyObject *swig_obj[1] ;
18002
18003 if (!args) SWIG_fail;
18004 swig_obj[0] = args;
18005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18006 if (!SWIG_IsOK(res1)) {
18007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18008 }
18009 arg1 = reinterpret_cast< wxGrid * >(argp1);
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj = 0;
18025 wxGrid *arg1 = (wxGrid *) 0 ;
18026 wxColour *arg2 = 0 ;
18027 void *argp1 = 0 ;
18028 int res1 = 0 ;
18029 wxColour temp2 ;
18030 PyObject * obj0 = 0 ;
18031 PyObject * obj1 = 0 ;
18032 char * kwnames[] = {
18033 (char *) "self",(char *) "c", NULL
18034 };
18035
18036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18038 if (!SWIG_IsOK(res1)) {
18039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18040 }
18041 arg1 = reinterpret_cast< wxGrid * >(argp1);
18042 {
18043 arg2 = &temp2;
18044 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_Py_Void();
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18060 PyObject *resultobj = 0;
18061 wxGrid *arg1 = (wxGrid *) 0 ;
18062 wxColour *arg2 = 0 ;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 wxColour temp2 ;
18066 PyObject * obj0 = 0 ;
18067 PyObject * obj1 = 0 ;
18068 char * kwnames[] = {
18069 (char *) "self",(char *) "c", NULL
18070 };
18071
18072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18074 if (!SWIG_IsOK(res1)) {
18075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18076 }
18077 arg1 = reinterpret_cast< wxGrid * >(argp1);
18078 {
18079 arg2 = &temp2;
18080 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18081 }
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 resultobj = SWIG_Py_Void();
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18096 PyObject *resultobj = 0;
18097 wxGrid *arg1 = (wxGrid *) 0 ;
18098 wxString *arg2 = 0 ;
18099 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18100 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18101 void *argp1 = 0 ;
18102 int res1 = 0 ;
18103 bool temp2 = false ;
18104 void *argp3 = 0 ;
18105 int res3 = 0 ;
18106 void *argp4 = 0 ;
18107 int res4 = 0 ;
18108 PyObject * obj0 = 0 ;
18109 PyObject * obj1 = 0 ;
18110 PyObject * obj2 = 0 ;
18111 PyObject * obj3 = 0 ;
18112 char * kwnames[] = {
18113 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18114 };
18115
18116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18118 if (!SWIG_IsOK(res1)) {
18119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18120 }
18121 arg1 = reinterpret_cast< wxGrid * >(argp1);
18122 {
18123 arg2 = wxString_in_helper(obj1);
18124 if (arg2 == NULL) SWIG_fail;
18125 temp2 = true;
18126 }
18127 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18128 if (!SWIG_IsOK(res3)) {
18129 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18130 }
18131 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18132 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18133 if (!SWIG_IsOK(res4)) {
18134 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18135 }
18136 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 resultobj = SWIG_Py_Void();
18144 {
18145 if (temp2)
18146 delete arg2;
18147 }
18148 return resultobj;
18149 fail:
18150 {
18151 if (temp2)
18152 delete arg2;
18153 }
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj = 0;
18160 wxGrid *arg1 = (wxGrid *) 0 ;
18161 int arg2 ;
18162 int arg3 ;
18163 wxGridCellEditor *result = 0 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 int val2 ;
18167 int ecode2 = 0 ;
18168 int val3 ;
18169 int ecode3 = 0 ;
18170 PyObject * obj0 = 0 ;
18171 PyObject * obj1 = 0 ;
18172 PyObject * obj2 = 0 ;
18173 char * kwnames[] = {
18174 (char *) "self",(char *) "row",(char *) "col", NULL
18175 };
18176
18177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18179 if (!SWIG_IsOK(res1)) {
18180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18181 }
18182 arg1 = reinterpret_cast< wxGrid * >(argp1);
18183 ecode2 = SWIG_AsVal_int(obj1, &val2);
18184 if (!SWIG_IsOK(ecode2)) {
18185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18186 }
18187 arg2 = static_cast< int >(val2);
18188 ecode3 = SWIG_AsVal_int(obj2, &val3);
18189 if (!SWIG_IsOK(ecode3)) {
18190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18191 }
18192 arg3 = static_cast< int >(val3);
18193 {
18194 PyThreadState* __tstate = wxPyBeginAllowThreads();
18195 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 {
18200 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18201 }
18202 return resultobj;
18203 fail:
18204 return NULL;
18205 }
18206
18207
18208 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj = 0;
18210 wxGrid *arg1 = (wxGrid *) 0 ;
18211 int arg2 ;
18212 int arg3 ;
18213 wxGridCellRenderer *result = 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 int val2 ;
18217 int ecode2 = 0 ;
18218 int val3 ;
18219 int ecode3 = 0 ;
18220 PyObject * obj0 = 0 ;
18221 PyObject * obj1 = 0 ;
18222 PyObject * obj2 = 0 ;
18223 char * kwnames[] = {
18224 (char *) "self",(char *) "row",(char *) "col", NULL
18225 };
18226
18227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18231 }
18232 arg1 = reinterpret_cast< wxGrid * >(argp1);
18233 ecode2 = SWIG_AsVal_int(obj1, &val2);
18234 if (!SWIG_IsOK(ecode2)) {
18235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18236 }
18237 arg2 = static_cast< int >(val2);
18238 ecode3 = SWIG_AsVal_int(obj2, &val3);
18239 if (!SWIG_IsOK(ecode3)) {
18240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18241 }
18242 arg3 = static_cast< int >(val3);
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 {
18250 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj = 0;
18260 wxGrid *arg1 = (wxGrid *) 0 ;
18261 wxString *arg2 = 0 ;
18262 wxGridCellEditor *result = 0 ;
18263 void *argp1 = 0 ;
18264 int res1 = 0 ;
18265 bool temp2 = false ;
18266 PyObject * obj0 = 0 ;
18267 PyObject * obj1 = 0 ;
18268 char * kwnames[] = {
18269 (char *) "self",(char *) "typeName", NULL
18270 };
18271
18272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18274 if (!SWIG_IsOK(res1)) {
18275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18276 }
18277 arg1 = reinterpret_cast< wxGrid * >(argp1);
18278 {
18279 arg2 = wxString_in_helper(obj1);
18280 if (arg2 == NULL) SWIG_fail;
18281 temp2 = true;
18282 }
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18291 }
18292 {
18293 if (temp2)
18294 delete arg2;
18295 }
18296 return resultobj;
18297 fail:
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 return NULL;
18303 }
18304
18305
18306 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj = 0;
18308 wxGrid *arg1 = (wxGrid *) 0 ;
18309 wxString *arg2 = 0 ;
18310 wxGridCellRenderer *result = 0 ;
18311 void *argp1 = 0 ;
18312 int res1 = 0 ;
18313 bool temp2 = false ;
18314 PyObject * obj0 = 0 ;
18315 PyObject * obj1 = 0 ;
18316 char * kwnames[] = {
18317 (char *) "self",(char *) "typeName", NULL
18318 };
18319
18320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18324 }
18325 arg1 = reinterpret_cast< wxGrid * >(argp1);
18326 {
18327 arg2 = wxString_in_helper(obj1);
18328 if (arg2 == NULL) SWIG_fail;
18329 temp2 = true;
18330 }
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 {
18338 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18339 }
18340 {
18341 if (temp2)
18342 delete arg2;
18343 }
18344 return resultobj;
18345 fail:
18346 {
18347 if (temp2)
18348 delete arg2;
18349 }
18350 return NULL;
18351 }
18352
18353
18354 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj = 0;
18356 wxGrid *arg1 = (wxGrid *) 0 ;
18357 int arg2 ;
18358 int arg3 ;
18359 void *argp1 = 0 ;
18360 int res1 = 0 ;
18361 int val2 ;
18362 int ecode2 = 0 ;
18363 int val3 ;
18364 int ecode3 = 0 ;
18365 PyObject * obj0 = 0 ;
18366 PyObject * obj1 = 0 ;
18367 PyObject * obj2 = 0 ;
18368 char * kwnames[] = {
18369 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18370 };
18371
18372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18376 }
18377 arg1 = reinterpret_cast< wxGrid * >(argp1);
18378 ecode2 = SWIG_AsVal_int(obj1, &val2);
18379 if (!SWIG_IsOK(ecode2)) {
18380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18381 }
18382 arg2 = static_cast< int >(val2);
18383 ecode3 = SWIG_AsVal_int(obj2, &val3);
18384 if (!SWIG_IsOK(ecode3)) {
18385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18386 }
18387 arg3 = static_cast< int >(val3);
18388 {
18389 PyThreadState* __tstate = wxPyBeginAllowThreads();
18390 (arg1)->SetMargins(arg2,arg3);
18391 wxPyEndAllowThreads(__tstate);
18392 if (PyErr_Occurred()) SWIG_fail;
18393 }
18394 resultobj = SWIG_Py_Void();
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18402 PyObject *resultobj = 0;
18403 wxGrid *arg1 = (wxGrid *) 0 ;
18404 wxWindow *result = 0 ;
18405 void *argp1 = 0 ;
18406 int res1 = 0 ;
18407 PyObject *swig_obj[1] ;
18408
18409 if (!args) SWIG_fail;
18410 swig_obj[0] = args;
18411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18412 if (!SWIG_IsOK(res1)) {
18413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18414 }
18415 arg1 = reinterpret_cast< wxGrid * >(argp1);
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 result = (wxWindow *)(arg1)->GetGridWindow();
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 {
18423 resultobj = wxPyMake_wxObject(result, 0);
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxGrid *arg1 = (wxGrid *) 0 ;
18434 wxWindow *result = 0 ;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18444 }
18445 arg1 = reinterpret_cast< wxGrid * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = wxPyMake_wxObject(result, 0);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18462 PyObject *resultobj = 0;
18463 wxGrid *arg1 = (wxGrid *) 0 ;
18464 wxWindow *result = 0 ;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 PyObject *swig_obj[1] ;
18468
18469 if (!args) SWIG_fail;
18470 swig_obj[0] = args;
18471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18474 }
18475 arg1 = reinterpret_cast< wxGrid * >(argp1);
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 {
18483 resultobj = wxPyMake_wxObject(result, 0);
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18492 PyObject *resultobj = 0;
18493 wxGrid *arg1 = (wxGrid *) 0 ;
18494 wxWindow *result = 0 ;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 PyObject *swig_obj[1] ;
18498
18499 if (!args) SWIG_fail;
18500 swig_obj[0] = args;
18501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18504 }
18505 arg1 = reinterpret_cast< wxGrid * >(argp1);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 {
18513 resultobj = wxPyMake_wxObject(result, 0);
18514 }
18515 return resultobj;
18516 fail:
18517 return NULL;
18518 }
18519
18520
18521 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18522 PyObject *resultobj = 0;
18523 wxGrid *arg1 = (wxGrid *) 0 ;
18524 int arg2 ;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 int val2 ;
18528 int ecode2 = 0 ;
18529 PyObject * obj0 = 0 ;
18530 PyObject * obj1 = 0 ;
18531 char * kwnames[] = {
18532 (char *) "self",(char *) "x", NULL
18533 };
18534
18535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18537 if (!SWIG_IsOK(res1)) {
18538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18539 }
18540 arg1 = reinterpret_cast< wxGrid * >(argp1);
18541 ecode2 = SWIG_AsVal_int(obj1, &val2);
18542 if (!SWIG_IsOK(ecode2)) {
18543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18544 }
18545 arg2 = static_cast< int >(val2);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 (arg1)->SetScrollLineX(arg2);
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 resultobj = SWIG_Py_Void();
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj = 0;
18561 wxGrid *arg1 = (wxGrid *) 0 ;
18562 int arg2 ;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 int val2 ;
18566 int ecode2 = 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "self",(char *) "y", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18577 }
18578 arg1 = reinterpret_cast< wxGrid * >(argp1);
18579 ecode2 = SWIG_AsVal_int(obj1, &val2);
18580 if (!SWIG_IsOK(ecode2)) {
18581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18582 }
18583 arg2 = static_cast< int >(val2);
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 (arg1)->SetScrollLineY(arg2);
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxGrid *arg1 = (wxGrid *) 0 ;
18600 int result;
18601 void *argp1 = 0 ;
18602 int res1 = 0 ;
18603 PyObject *swig_obj[1] ;
18604
18605 if (!args) SWIG_fail;
18606 swig_obj[0] = args;
18607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18610 }
18611 arg1 = reinterpret_cast< wxGrid * >(argp1);
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 resultobj = SWIG_From_int(static_cast< int >(result));
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18626 PyObject *resultobj = 0;
18627 wxGrid *arg1 = (wxGrid *) 0 ;
18628 int result;
18629 void *argp1 = 0 ;
18630 int res1 = 0 ;
18631 PyObject *swig_obj[1] ;
18632
18633 if (!args) SWIG_fail;
18634 swig_obj[0] = args;
18635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18638 }
18639 arg1 = reinterpret_cast< wxGrid * >(argp1);
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 resultobj = SWIG_From_int(static_cast< int >(result));
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj = 0;
18655 wxGrid *arg1 = (wxGrid *) 0 ;
18656 int arg2 ;
18657 int result;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 int val2 ;
18661 int ecode2 = 0 ;
18662 PyObject * obj0 = 0 ;
18663 PyObject * obj1 = 0 ;
18664 char * kwnames[] = {
18665 (char *) "self",(char *) "x", NULL
18666 };
18667
18668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18670 if (!SWIG_IsOK(res1)) {
18671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18672 }
18673 arg1 = reinterpret_cast< wxGrid * >(argp1);
18674 ecode2 = SWIG_AsVal_int(obj1, &val2);
18675 if (!SWIG_IsOK(ecode2)) {
18676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18677 }
18678 arg2 = static_cast< int >(val2);
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_From_int(static_cast< int >(result));
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxGrid *arg1 = (wxGrid *) 0 ;
18695 int arg2 ;
18696 int result;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 int val2 ;
18700 int ecode2 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char * kwnames[] = {
18704 (char *) "self",(char *) "y", NULL
18705 };
18706
18707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18709 if (!SWIG_IsOK(res1)) {
18710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18711 }
18712 arg1 = reinterpret_cast< wxGrid * >(argp1);
18713 ecode2 = SWIG_AsVal_int(obj1, &val2);
18714 if (!SWIG_IsOK(ecode2)) {
18715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18716 }
18717 arg2 = static_cast< int >(val2);
18718 {
18719 PyThreadState* __tstate = wxPyBeginAllowThreads();
18720 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 resultobj = SWIG_From_int(static_cast< int >(result));
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj = 0;
18733 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18734 SwigValueWrapper<wxVisualAttributes > result;
18735 int val1 ;
18736 int ecode1 = 0 ;
18737 PyObject * obj0 = 0 ;
18738 char * kwnames[] = {
18739 (char *) "variant", NULL
18740 };
18741
18742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18743 if (obj0) {
18744 ecode1 = SWIG_AsVal_int(obj0, &val1);
18745 if (!SWIG_IsOK(ecode1)) {
18746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18747 }
18748 arg1 = static_cast< wxWindowVariant >(val1);
18749 }
18750 {
18751 if (!wxPyCheckForApp()) SWIG_fail;
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 result = wxGrid::GetClassDefaultAttributes(arg1);
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *obj;
18766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18767 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18768 return SWIG_Py_Void();
18769 }
18770
18771 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772 return SWIG_Python_InitShadowInstance(args);
18773 }
18774
18775 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj = 0;
18777 int arg1 ;
18778 wxEventType arg2 ;
18779 wxGrid *arg3 = (wxGrid *) 0 ;
18780 int arg4 = (int) -1 ;
18781 int arg5 = (int) -1 ;
18782 int arg6 = (int) -1 ;
18783 int arg7 = (int) -1 ;
18784 bool arg8 = (bool) true ;
18785 bool arg9 = (bool) false ;
18786 bool arg10 = (bool) false ;
18787 bool arg11 = (bool) false ;
18788 bool arg12 = (bool) false ;
18789 wxGridEvent *result = 0 ;
18790 int val1 ;
18791 int ecode1 = 0 ;
18792 int val2 ;
18793 int ecode2 = 0 ;
18794 void *argp3 = 0 ;
18795 int res3 = 0 ;
18796 int val4 ;
18797 int ecode4 = 0 ;
18798 int val5 ;
18799 int ecode5 = 0 ;
18800 int val6 ;
18801 int ecode6 = 0 ;
18802 int val7 ;
18803 int ecode7 = 0 ;
18804 bool val8 ;
18805 int ecode8 = 0 ;
18806 bool val9 ;
18807 int ecode9 = 0 ;
18808 bool val10 ;
18809 int ecode10 = 0 ;
18810 bool val11 ;
18811 int ecode11 = 0 ;
18812 bool val12 ;
18813 int ecode12 = 0 ;
18814 PyObject * obj0 = 0 ;
18815 PyObject * obj1 = 0 ;
18816 PyObject * obj2 = 0 ;
18817 PyObject * obj3 = 0 ;
18818 PyObject * obj4 = 0 ;
18819 PyObject * obj5 = 0 ;
18820 PyObject * obj6 = 0 ;
18821 PyObject * obj7 = 0 ;
18822 PyObject * obj8 = 0 ;
18823 PyObject * obj9 = 0 ;
18824 PyObject * obj10 = 0 ;
18825 PyObject * obj11 = 0 ;
18826 char * kwnames[] = {
18827 (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
18828 };
18829
18830 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;
18831 ecode1 = SWIG_AsVal_int(obj0, &val1);
18832 if (!SWIG_IsOK(ecode1)) {
18833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18834 }
18835 arg1 = static_cast< int >(val1);
18836 ecode2 = SWIG_AsVal_int(obj1, &val2);
18837 if (!SWIG_IsOK(ecode2)) {
18838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18839 }
18840 arg2 = static_cast< wxEventType >(val2);
18841 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18842 if (!SWIG_IsOK(res3)) {
18843 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18844 }
18845 arg3 = reinterpret_cast< wxGrid * >(argp3);
18846 if (obj3) {
18847 ecode4 = SWIG_AsVal_int(obj3, &val4);
18848 if (!SWIG_IsOK(ecode4)) {
18849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18850 }
18851 arg4 = static_cast< int >(val4);
18852 }
18853 if (obj4) {
18854 ecode5 = SWIG_AsVal_int(obj4, &val5);
18855 if (!SWIG_IsOK(ecode5)) {
18856 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18857 }
18858 arg5 = static_cast< int >(val5);
18859 }
18860 if (obj5) {
18861 ecode6 = SWIG_AsVal_int(obj5, &val6);
18862 if (!SWIG_IsOK(ecode6)) {
18863 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18864 }
18865 arg6 = static_cast< int >(val6);
18866 }
18867 if (obj6) {
18868 ecode7 = SWIG_AsVal_int(obj6, &val7);
18869 if (!SWIG_IsOK(ecode7)) {
18870 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18871 }
18872 arg7 = static_cast< int >(val7);
18873 }
18874 if (obj7) {
18875 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18876 if (!SWIG_IsOK(ecode8)) {
18877 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18878 }
18879 arg8 = static_cast< bool >(val8);
18880 }
18881 if (obj8) {
18882 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18883 if (!SWIG_IsOK(ecode9)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18885 }
18886 arg9 = static_cast< bool >(val9);
18887 }
18888 if (obj9) {
18889 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18890 if (!SWIG_IsOK(ecode10)) {
18891 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18892 }
18893 arg10 = static_cast< bool >(val10);
18894 }
18895 if (obj10) {
18896 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18897 if (!SWIG_IsOK(ecode11)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18899 }
18900 arg11 = static_cast< bool >(val11);
18901 }
18902 if (obj11) {
18903 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18904 if (!SWIG_IsOK(ecode12)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18906 }
18907 arg12 = static_cast< bool >(val12);
18908 }
18909 {
18910 PyThreadState* __tstate = wxPyBeginAllowThreads();
18911 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18923 PyObject *resultobj = 0;
18924 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18925 int result;
18926 void *argp1 = 0 ;
18927 int res1 = 0 ;
18928 PyObject *swig_obj[1] ;
18929
18930 if (!args) SWIG_fail;
18931 swig_obj[0] = args;
18932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18935 }
18936 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18937 {
18938 PyThreadState* __tstate = wxPyBeginAllowThreads();
18939 result = (int)(arg1)->GetRow();
18940 wxPyEndAllowThreads(__tstate);
18941 if (PyErr_Occurred()) SWIG_fail;
18942 }
18943 resultobj = SWIG_From_int(static_cast< int >(result));
18944 return resultobj;
18945 fail:
18946 return NULL;
18947 }
18948
18949
18950 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18951 PyObject *resultobj = 0;
18952 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18953 int result;
18954 void *argp1 = 0 ;
18955 int res1 = 0 ;
18956 PyObject *swig_obj[1] ;
18957
18958 if (!args) SWIG_fail;
18959 swig_obj[0] = args;
18960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18961 if (!SWIG_IsOK(res1)) {
18962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18963 }
18964 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18965 {
18966 PyThreadState* __tstate = wxPyBeginAllowThreads();
18967 result = (int)(arg1)->GetCol();
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 resultobj = SWIG_From_int(static_cast< int >(result));
18972 return resultobj;
18973 fail:
18974 return NULL;
18975 }
18976
18977
18978 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18979 PyObject *resultobj = 0;
18980 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18981 wxPoint result;
18982 void *argp1 = 0 ;
18983 int res1 = 0 ;
18984 PyObject *swig_obj[1] ;
18985
18986 if (!args) SWIG_fail;
18987 swig_obj[0] = args;
18988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18989 if (!SWIG_IsOK(res1)) {
18990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18991 }
18992 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 result = (arg1)->GetPosition();
18996 wxPyEndAllowThreads(__tstate);
18997 if (PyErr_Occurred()) SWIG_fail;
18998 }
18999 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19000 return resultobj;
19001 fail:
19002 return NULL;
19003 }
19004
19005
19006 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19007 PyObject *resultobj = 0;
19008 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19009 bool result;
19010 void *argp1 = 0 ;
19011 int res1 = 0 ;
19012 PyObject *swig_obj[1] ;
19013
19014 if (!args) SWIG_fail;
19015 swig_obj[0] = args;
19016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19017 if (!SWIG_IsOK(res1)) {
19018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19019 }
19020 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 result = (bool)(arg1)->Selecting();
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 {
19028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19029 }
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19037 PyObject *resultobj = 0;
19038 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19039 bool result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 PyObject *swig_obj[1] ;
19043
19044 if (!args) SWIG_fail;
19045 swig_obj[0] = args;
19046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19049 }
19050 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 result = (bool)(arg1)->ControlDown();
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 {
19058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19059 }
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19067 PyObject *resultobj = 0;
19068 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19069 bool result;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 PyObject *swig_obj[1] ;
19073
19074 if (!args) SWIG_fail;
19075 swig_obj[0] = args;
19076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19077 if (!SWIG_IsOK(res1)) {
19078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19079 }
19080 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 result = (bool)(arg1)->MetaDown();
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 {
19088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19089 }
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19097 PyObject *resultobj = 0;
19098 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19099 bool result;
19100 void *argp1 = 0 ;
19101 int res1 = 0 ;
19102 PyObject *swig_obj[1] ;
19103
19104 if (!args) SWIG_fail;
19105 swig_obj[0] = args;
19106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19107 if (!SWIG_IsOK(res1)) {
19108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19109 }
19110 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (bool)(arg1)->ShiftDown();
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *resultobj = 0;
19128 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19129 bool result;
19130 void *argp1 = 0 ;
19131 int res1 = 0 ;
19132 PyObject *swig_obj[1] ;
19133
19134 if (!args) SWIG_fail;
19135 swig_obj[0] = args;
19136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19137 if (!SWIG_IsOK(res1)) {
19138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19139 }
19140 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19141 {
19142 PyThreadState* __tstate = wxPyBeginAllowThreads();
19143 result = (bool)(arg1)->AltDown();
19144 wxPyEndAllowThreads(__tstate);
19145 if (PyErr_Occurred()) SWIG_fail;
19146 }
19147 {
19148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19149 }
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19157 PyObject *resultobj = 0;
19158 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19159 bool result;
19160 void *argp1 = 0 ;
19161 int res1 = 0 ;
19162 PyObject *swig_obj[1] ;
19163
19164 if (!args) SWIG_fail;
19165 swig_obj[0] = args;
19166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19167 if (!SWIG_IsOK(res1)) {
19168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19169 }
19170 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19171 {
19172 PyThreadState* __tstate = wxPyBeginAllowThreads();
19173 result = (bool)(arg1)->CmdDown();
19174 wxPyEndAllowThreads(__tstate);
19175 if (PyErr_Occurred()) SWIG_fail;
19176 }
19177 {
19178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19179 }
19180 return resultobj;
19181 fail:
19182 return NULL;
19183 }
19184
19185
19186 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19187 PyObject *obj;
19188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19189 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19190 return SWIG_Py_Void();
19191 }
19192
19193 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194 return SWIG_Python_InitShadowInstance(args);
19195 }
19196
19197 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 int arg1 ;
19200 wxEventType arg2 ;
19201 wxGrid *arg3 = (wxGrid *) 0 ;
19202 int arg4 = (int) -1 ;
19203 int arg5 = (int) -1 ;
19204 int arg6 = (int) -1 ;
19205 bool arg7 = (bool) false ;
19206 bool arg8 = (bool) false ;
19207 bool arg9 = (bool) false ;
19208 bool arg10 = (bool) false ;
19209 wxGridSizeEvent *result = 0 ;
19210 int val1 ;
19211 int ecode1 = 0 ;
19212 int val2 ;
19213 int ecode2 = 0 ;
19214 void *argp3 = 0 ;
19215 int res3 = 0 ;
19216 int val4 ;
19217 int ecode4 = 0 ;
19218 int val5 ;
19219 int ecode5 = 0 ;
19220 int val6 ;
19221 int ecode6 = 0 ;
19222 bool val7 ;
19223 int ecode7 = 0 ;
19224 bool val8 ;
19225 int ecode8 = 0 ;
19226 bool val9 ;
19227 int ecode9 = 0 ;
19228 bool val10 ;
19229 int ecode10 = 0 ;
19230 PyObject * obj0 = 0 ;
19231 PyObject * obj1 = 0 ;
19232 PyObject * obj2 = 0 ;
19233 PyObject * obj3 = 0 ;
19234 PyObject * obj4 = 0 ;
19235 PyObject * obj5 = 0 ;
19236 PyObject * obj6 = 0 ;
19237 PyObject * obj7 = 0 ;
19238 PyObject * obj8 = 0 ;
19239 PyObject * obj9 = 0 ;
19240 char * kwnames[] = {
19241 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19242 };
19243
19244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19245 ecode1 = SWIG_AsVal_int(obj0, &val1);
19246 if (!SWIG_IsOK(ecode1)) {
19247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19248 }
19249 arg1 = static_cast< int >(val1);
19250 ecode2 = SWIG_AsVal_int(obj1, &val2);
19251 if (!SWIG_IsOK(ecode2)) {
19252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19253 }
19254 arg2 = static_cast< wxEventType >(val2);
19255 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19256 if (!SWIG_IsOK(res3)) {
19257 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19258 }
19259 arg3 = reinterpret_cast< wxGrid * >(argp3);
19260 if (obj3) {
19261 ecode4 = SWIG_AsVal_int(obj3, &val4);
19262 if (!SWIG_IsOK(ecode4)) {
19263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19264 }
19265 arg4 = static_cast< int >(val4);
19266 }
19267 if (obj4) {
19268 ecode5 = SWIG_AsVal_int(obj4, &val5);
19269 if (!SWIG_IsOK(ecode5)) {
19270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19271 }
19272 arg5 = static_cast< int >(val5);
19273 }
19274 if (obj5) {
19275 ecode6 = SWIG_AsVal_int(obj5, &val6);
19276 if (!SWIG_IsOK(ecode6)) {
19277 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19278 }
19279 arg6 = static_cast< int >(val6);
19280 }
19281 if (obj6) {
19282 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19283 if (!SWIG_IsOK(ecode7)) {
19284 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19285 }
19286 arg7 = static_cast< bool >(val7);
19287 }
19288 if (obj7) {
19289 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19290 if (!SWIG_IsOK(ecode8)) {
19291 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19292 }
19293 arg8 = static_cast< bool >(val8);
19294 }
19295 if (obj8) {
19296 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19297 if (!SWIG_IsOK(ecode9)) {
19298 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19299 }
19300 arg9 = static_cast< bool >(val9);
19301 }
19302 if (obj9) {
19303 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19304 if (!SWIG_IsOK(ecode10)) {
19305 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19306 }
19307 arg10 = static_cast< bool >(val10);
19308 }
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19316 return resultobj;
19317 fail:
19318 return NULL;
19319 }
19320
19321
19322 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19323 PyObject *resultobj = 0;
19324 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19325 int result;
19326 void *argp1 = 0 ;
19327 int res1 = 0 ;
19328 PyObject *swig_obj[1] ;
19329
19330 if (!args) SWIG_fail;
19331 swig_obj[0] = args;
19332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19333 if (!SWIG_IsOK(res1)) {
19334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19335 }
19336 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 result = (int)(arg1)->GetRowOrCol();
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_From_int(static_cast< int >(result));
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19353 wxPoint result;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19363 }
19364 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (arg1)->GetPosition();
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19381 bool result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19391 }
19392 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (bool)(arg1)->ControlDown();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 {
19400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19409 PyObject *resultobj = 0;
19410 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19411 bool result;
19412 void *argp1 = 0 ;
19413 int res1 = 0 ;
19414 PyObject *swig_obj[1] ;
19415
19416 if (!args) SWIG_fail;
19417 swig_obj[0] = args;
19418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19421 }
19422 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19423 {
19424 PyThreadState* __tstate = wxPyBeginAllowThreads();
19425 result = (bool)(arg1)->MetaDown();
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 {
19430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19431 }
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19439 PyObject *resultobj = 0;
19440 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19441 bool result;
19442 void *argp1 = 0 ;
19443 int res1 = 0 ;
19444 PyObject *swig_obj[1] ;
19445
19446 if (!args) SWIG_fail;
19447 swig_obj[0] = args;
19448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19449 if (!SWIG_IsOK(res1)) {
19450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19451 }
19452 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (bool)(arg1)->ShiftDown();
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 {
19460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19461 }
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19469 PyObject *resultobj = 0;
19470 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19471 bool result;
19472 void *argp1 = 0 ;
19473 int res1 = 0 ;
19474 PyObject *swig_obj[1] ;
19475
19476 if (!args) SWIG_fail;
19477 swig_obj[0] = args;
19478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19479 if (!SWIG_IsOK(res1)) {
19480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19481 }
19482 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (bool)(arg1)->AltDown();
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 {
19490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19491 }
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19499 PyObject *resultobj = 0;
19500 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19501 bool result;
19502 void *argp1 = 0 ;
19503 int res1 = 0 ;
19504 PyObject *swig_obj[1] ;
19505
19506 if (!args) SWIG_fail;
19507 swig_obj[0] = args;
19508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19509 if (!SWIG_IsOK(res1)) {
19510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19511 }
19512 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 result = (bool)(arg1)->CmdDown();
19516 wxPyEndAllowThreads(__tstate);
19517 if (PyErr_Occurred()) SWIG_fail;
19518 }
19519 {
19520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19521 }
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19529 PyObject *obj;
19530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19531 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19532 return SWIG_Py_Void();
19533 }
19534
19535 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19536 return SWIG_Python_InitShadowInstance(args);
19537 }
19538
19539 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19540 PyObject *resultobj = 0;
19541 int arg1 ;
19542 wxEventType arg2 ;
19543 wxGrid *arg3 = (wxGrid *) 0 ;
19544 wxGridCellCoords *arg4 = 0 ;
19545 wxGridCellCoords *arg5 = 0 ;
19546 bool arg6 = (bool) true ;
19547 bool arg7 = (bool) false ;
19548 bool arg8 = (bool) false ;
19549 bool arg9 = (bool) false ;
19550 bool arg10 = (bool) false ;
19551 wxGridRangeSelectEvent *result = 0 ;
19552 int val1 ;
19553 int ecode1 = 0 ;
19554 int val2 ;
19555 int ecode2 = 0 ;
19556 void *argp3 = 0 ;
19557 int res3 = 0 ;
19558 wxGridCellCoords temp4 ;
19559 wxGridCellCoords temp5 ;
19560 bool val6 ;
19561 int ecode6 = 0 ;
19562 bool val7 ;
19563 int ecode7 = 0 ;
19564 bool val8 ;
19565 int ecode8 = 0 ;
19566 bool val9 ;
19567 int ecode9 = 0 ;
19568 bool val10 ;
19569 int ecode10 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 PyObject * obj4 = 0 ;
19575 PyObject * obj5 = 0 ;
19576 PyObject * obj6 = 0 ;
19577 PyObject * obj7 = 0 ;
19578 PyObject * obj8 = 0 ;
19579 PyObject * obj9 = 0 ;
19580 char * kwnames[] = {
19581 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19582 };
19583
19584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19585 ecode1 = SWIG_AsVal_int(obj0, &val1);
19586 if (!SWIG_IsOK(ecode1)) {
19587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19588 }
19589 arg1 = static_cast< int >(val1);
19590 ecode2 = SWIG_AsVal_int(obj1, &val2);
19591 if (!SWIG_IsOK(ecode2)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19593 }
19594 arg2 = static_cast< wxEventType >(val2);
19595 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19596 if (!SWIG_IsOK(res3)) {
19597 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19598 }
19599 arg3 = reinterpret_cast< wxGrid * >(argp3);
19600 {
19601 arg4 = &temp4;
19602 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19603 }
19604 {
19605 arg5 = &temp5;
19606 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19607 }
19608 if (obj5) {
19609 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19610 if (!SWIG_IsOK(ecode6)) {
19611 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19612 }
19613 arg6 = static_cast< bool >(val6);
19614 }
19615 if (obj6) {
19616 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19617 if (!SWIG_IsOK(ecode7)) {
19618 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19619 }
19620 arg7 = static_cast< bool >(val7);
19621 }
19622 if (obj7) {
19623 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19624 if (!SWIG_IsOK(ecode8)) {
19625 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19626 }
19627 arg8 = static_cast< bool >(val8);
19628 }
19629 if (obj8) {
19630 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19631 if (!SWIG_IsOK(ecode9)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19633 }
19634 arg9 = static_cast< bool >(val9);
19635 }
19636 if (obj9) {
19637 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19638 if (!SWIG_IsOK(ecode10)) {
19639 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19640 }
19641 arg10 = static_cast< bool >(val10);
19642 }
19643 {
19644 PyThreadState* __tstate = wxPyBeginAllowThreads();
19645 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19646 wxPyEndAllowThreads(__tstate);
19647 if (PyErr_Occurred()) SWIG_fail;
19648 }
19649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19650 return resultobj;
19651 fail:
19652 return NULL;
19653 }
19654
19655
19656 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19657 PyObject *resultobj = 0;
19658 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19659 wxGridCellCoords result;
19660 void *argp1 = 0 ;
19661 int res1 = 0 ;
19662 PyObject *swig_obj[1] ;
19663
19664 if (!args) SWIG_fail;
19665 swig_obj[0] = args;
19666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19669 }
19670 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 result = (arg1)->GetTopLeftCoords();
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19685 PyObject *resultobj = 0;
19686 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19687 wxGridCellCoords result;
19688 void *argp1 = 0 ;
19689 int res1 = 0 ;
19690 PyObject *swig_obj[1] ;
19691
19692 if (!args) SWIG_fail;
19693 swig_obj[0] = args;
19694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19695 if (!SWIG_IsOK(res1)) {
19696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19697 }
19698 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 result = (arg1)->GetBottomRightCoords();
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19713 PyObject *resultobj = 0;
19714 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19715 int result;
19716 void *argp1 = 0 ;
19717 int res1 = 0 ;
19718 PyObject *swig_obj[1] ;
19719
19720 if (!args) SWIG_fail;
19721 swig_obj[0] = args;
19722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19725 }
19726 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (int)(arg1)->GetTopRow();
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_From_int(static_cast< int >(result));
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 PyObject *resultobj = 0;
19742 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19743 int result;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 PyObject *swig_obj[1] ;
19747
19748 if (!args) SWIG_fail;
19749 swig_obj[0] = args;
19750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19753 }
19754 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19755 {
19756 PyThreadState* __tstate = wxPyBeginAllowThreads();
19757 result = (int)(arg1)->GetBottomRow();
19758 wxPyEndAllowThreads(__tstate);
19759 if (PyErr_Occurred()) SWIG_fail;
19760 }
19761 resultobj = SWIG_From_int(static_cast< int >(result));
19762 return resultobj;
19763 fail:
19764 return NULL;
19765 }
19766
19767
19768 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19769 PyObject *resultobj = 0;
19770 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19771 int result;
19772 void *argp1 = 0 ;
19773 int res1 = 0 ;
19774 PyObject *swig_obj[1] ;
19775
19776 if (!args) SWIG_fail;
19777 swig_obj[0] = args;
19778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19779 if (!SWIG_IsOK(res1)) {
19780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19781 }
19782 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (int)(arg1)->GetLeftCol();
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_From_int(static_cast< int >(result));
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19797 PyObject *resultobj = 0;
19798 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19799 int result;
19800 void *argp1 = 0 ;
19801 int res1 = 0 ;
19802 PyObject *swig_obj[1] ;
19803
19804 if (!args) SWIG_fail;
19805 swig_obj[0] = args;
19806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19807 if (!SWIG_IsOK(res1)) {
19808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19809 }
19810 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 result = (int)(arg1)->GetRightCol();
19814 wxPyEndAllowThreads(__tstate);
19815 if (PyErr_Occurred()) SWIG_fail;
19816 }
19817 resultobj = SWIG_From_int(static_cast< int >(result));
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19825 PyObject *resultobj = 0;
19826 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19827 bool result;
19828 void *argp1 = 0 ;
19829 int res1 = 0 ;
19830 PyObject *swig_obj[1] ;
19831
19832 if (!args) SWIG_fail;
19833 swig_obj[0] = args;
19834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19835 if (!SWIG_IsOK(res1)) {
19836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19837 }
19838 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (bool)(arg1)->Selecting();
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 {
19846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19847 }
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19855 PyObject *resultobj = 0;
19856 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19857 bool result;
19858 void *argp1 = 0 ;
19859 int res1 = 0 ;
19860 PyObject *swig_obj[1] ;
19861
19862 if (!args) SWIG_fail;
19863 swig_obj[0] = args;
19864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19867 }
19868 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (bool)(arg1)->ControlDown();
19872 wxPyEndAllowThreads(__tstate);
19873 if (PyErr_Occurred()) SWIG_fail;
19874 }
19875 {
19876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19877 }
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 PyObject *resultobj = 0;
19886 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19887 bool result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 PyObject *swig_obj[1] ;
19891
19892 if (!args) SWIG_fail;
19893 swig_obj[0] = args;
19894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19895 if (!SWIG_IsOK(res1)) {
19896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19897 }
19898 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (bool)(arg1)->MetaDown();
19902 wxPyEndAllowThreads(__tstate);
19903 if (PyErr_Occurred()) SWIG_fail;
19904 }
19905 {
19906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19907 }
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19915 PyObject *resultobj = 0;
19916 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19917 bool result;
19918 void *argp1 = 0 ;
19919 int res1 = 0 ;
19920 PyObject *swig_obj[1] ;
19921
19922 if (!args) SWIG_fail;
19923 swig_obj[0] = args;
19924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19927 }
19928 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 result = (bool)(arg1)->ShiftDown();
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 {
19936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19937 }
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19945 PyObject *resultobj = 0;
19946 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19947 bool result;
19948 void *argp1 = 0 ;
19949 int res1 = 0 ;
19950 PyObject *swig_obj[1] ;
19951
19952 if (!args) SWIG_fail;
19953 swig_obj[0] = args;
19954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19955 if (!SWIG_IsOK(res1)) {
19956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19957 }
19958 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 result = (bool)(arg1)->AltDown();
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 {
19966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19967 }
19968 return resultobj;
19969 fail:
19970 return NULL;
19971 }
19972
19973
19974 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19975 PyObject *resultobj = 0;
19976 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19977 bool result;
19978 void *argp1 = 0 ;
19979 int res1 = 0 ;
19980 PyObject *swig_obj[1] ;
19981
19982 if (!args) SWIG_fail;
19983 swig_obj[0] = args;
19984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19985 if (!SWIG_IsOK(res1)) {
19986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19987 }
19988 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19989 {
19990 PyThreadState* __tstate = wxPyBeginAllowThreads();
19991 result = (bool)(arg1)->CmdDown();
19992 wxPyEndAllowThreads(__tstate);
19993 if (PyErr_Occurred()) SWIG_fail;
19994 }
19995 {
19996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19997 }
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20005 PyObject *obj;
20006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20007 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20008 return SWIG_Py_Void();
20009 }
20010
20011 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012 return SWIG_Python_InitShadowInstance(args);
20013 }
20014
20015 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20016 PyObject *resultobj = 0;
20017 int arg1 ;
20018 wxEventType arg2 ;
20019 wxObject *arg3 = (wxObject *) 0 ;
20020 int arg4 ;
20021 int arg5 ;
20022 wxControl *arg6 = (wxControl *) 0 ;
20023 wxGridEditorCreatedEvent *result = 0 ;
20024 int val1 ;
20025 int ecode1 = 0 ;
20026 int val2 ;
20027 int ecode2 = 0 ;
20028 void *argp3 = 0 ;
20029 int res3 = 0 ;
20030 int val4 ;
20031 int ecode4 = 0 ;
20032 int val5 ;
20033 int ecode5 = 0 ;
20034 void *argp6 = 0 ;
20035 int res6 = 0 ;
20036 PyObject * obj0 = 0 ;
20037 PyObject * obj1 = 0 ;
20038 PyObject * obj2 = 0 ;
20039 PyObject * obj3 = 0 ;
20040 PyObject * obj4 = 0 ;
20041 PyObject * obj5 = 0 ;
20042 char * kwnames[] = {
20043 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20044 };
20045
20046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20047 ecode1 = SWIG_AsVal_int(obj0, &val1);
20048 if (!SWIG_IsOK(ecode1)) {
20049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20050 }
20051 arg1 = static_cast< int >(val1);
20052 ecode2 = SWIG_AsVal_int(obj1, &val2);
20053 if (!SWIG_IsOK(ecode2)) {
20054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20055 }
20056 arg2 = static_cast< wxEventType >(val2);
20057 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20058 if (!SWIG_IsOK(res3)) {
20059 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20060 }
20061 arg3 = reinterpret_cast< wxObject * >(argp3);
20062 ecode4 = SWIG_AsVal_int(obj3, &val4);
20063 if (!SWIG_IsOK(ecode4)) {
20064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20065 }
20066 arg4 = static_cast< int >(val4);
20067 ecode5 = SWIG_AsVal_int(obj4, &val5);
20068 if (!SWIG_IsOK(ecode5)) {
20069 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20070 }
20071 arg5 = static_cast< int >(val5);
20072 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20073 if (!SWIG_IsOK(res6)) {
20074 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20075 }
20076 arg6 = reinterpret_cast< wxControl * >(argp6);
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20091 PyObject *resultobj = 0;
20092 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20093 int result;
20094 void *argp1 = 0 ;
20095 int res1 = 0 ;
20096 PyObject *swig_obj[1] ;
20097
20098 if (!args) SWIG_fail;
20099 swig_obj[0] = args;
20100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20101 if (!SWIG_IsOK(res1)) {
20102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20103 }
20104 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (int)(arg1)->GetRow();
20108 wxPyEndAllowThreads(__tstate);
20109 if (PyErr_Occurred()) SWIG_fail;
20110 }
20111 resultobj = SWIG_From_int(static_cast< int >(result));
20112 return resultobj;
20113 fail:
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20119 PyObject *resultobj = 0;
20120 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20121 int result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 PyObject *swig_obj[1] ;
20125
20126 if (!args) SWIG_fail;
20127 swig_obj[0] = args;
20128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20129 if (!SWIG_IsOK(res1)) {
20130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20131 }
20132 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (int)(arg1)->GetCol();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_From_int(static_cast< int >(result));
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20149 wxControl *result = 0 ;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20159 }
20160 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (wxControl *)(arg1)->GetControl();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = wxPyMake_wxObject(result, 0);
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj = 0;
20178 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20179 int arg2 ;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 int val2 ;
20183 int ecode2 = 0 ;
20184 PyObject * obj0 = 0 ;
20185 PyObject * obj1 = 0 ;
20186 char * kwnames[] = {
20187 (char *) "self",(char *) "row", NULL
20188 };
20189
20190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20194 }
20195 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20196 ecode2 = SWIG_AsVal_int(obj1, &val2);
20197 if (!SWIG_IsOK(ecode2)) {
20198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20199 }
20200 arg2 = static_cast< int >(val2);
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 (arg1)->SetRow(arg2);
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 resultobj = SWIG_Py_Void();
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj = 0;
20216 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20217 int arg2 ;
20218 void *argp1 = 0 ;
20219 int res1 = 0 ;
20220 int val2 ;
20221 int ecode2 = 0 ;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 char * kwnames[] = {
20225 (char *) "self",(char *) "col", NULL
20226 };
20227
20228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20230 if (!SWIG_IsOK(res1)) {
20231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20232 }
20233 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20234 ecode2 = SWIG_AsVal_int(obj1, &val2);
20235 if (!SWIG_IsOK(ecode2)) {
20236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20237 }
20238 arg2 = static_cast< int >(val2);
20239 {
20240 PyThreadState* __tstate = wxPyBeginAllowThreads();
20241 (arg1)->SetCol(arg2);
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 resultobj = SWIG_Py_Void();
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj = 0;
20254 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20255 wxControl *arg2 = (wxControl *) 0 ;
20256 void *argp1 = 0 ;
20257 int res1 = 0 ;
20258 void *argp2 = 0 ;
20259 int res2 = 0 ;
20260 PyObject * obj0 = 0 ;
20261 PyObject * obj1 = 0 ;
20262 char * kwnames[] = {
20263 (char *) "self",(char *) "ctrl", NULL
20264 };
20265
20266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20268 if (!SWIG_IsOK(res1)) {
20269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20270 }
20271 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20273 if (!SWIG_IsOK(res2)) {
20274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20275 }
20276 arg2 = reinterpret_cast< wxControl * >(argp2);
20277 {
20278 PyThreadState* __tstate = wxPyBeginAllowThreads();
20279 (arg1)->SetControl(arg2);
20280 wxPyEndAllowThreads(__tstate);
20281 if (PyErr_Occurred()) SWIG_fail;
20282 }
20283 resultobj = SWIG_Py_Void();
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20291 PyObject *obj;
20292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20293 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20294 return SWIG_Py_Void();
20295 }
20296
20297 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 return SWIG_Python_InitShadowInstance(args);
20299 }
20300
20301 static PyMethodDef SwigMethods[] = {
20302 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20303 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20304 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20305 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20306 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20307 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20308 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20309 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20310 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20313 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20314 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20315 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20316 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20317 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20318 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20319 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20320 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20321 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20322 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20323 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20324 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20325 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20326 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20327 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20328 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20329 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20330 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20331 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20332 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20333 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20334 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20335 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20336 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20337 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20338 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20339 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20340 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20341 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20342 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20343 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20344 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20345 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20346 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20347 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20348 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20349 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20350 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20351 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20353 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20355 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20357 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20358 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20359 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20362 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20363 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20364 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20365 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20366 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20367 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20368 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20369 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20370 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20372 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20373 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20374 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20375 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20376 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20377 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20378 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20379 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20381 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20382 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20383 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20384 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20385 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20388 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20389 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20391 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20392 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20402 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20403 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20404 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20405 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20406 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20407 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20408 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20409 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20410 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20411 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20412 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20413 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20414 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20415 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20416 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20419 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20420 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20422 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20423 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20424 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20432 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20433 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20434 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20440 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20441 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20442 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20443 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20445 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20447 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20448 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20449 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20452 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20453 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20454 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20458 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20462 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20473 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20478 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20479 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20481 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20482 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20483 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20485 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20486 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20488 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20490 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20492 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20494 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20496 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20497 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20498 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20500 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20501 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20503 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20508 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20509 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20510 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20512 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20516 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20517 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20518 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20520 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20522 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20532 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20533 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20534 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20535 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20536 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20539 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20540 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20541 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20542 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20543 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20544 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20545 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20546 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20553 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20554 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20562 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20563 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20568 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20569 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20570 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20571 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20572 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20573 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20574 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20575 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20576 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20577 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20580 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20581 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20584 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20585 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20586 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20602 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20603 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20605 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20606 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20608 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20609 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20611 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20612 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20614 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20615 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20625 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20626 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20628 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20630 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20632 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20634 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20636 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20638 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20652 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20659 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20660 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20674 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20678 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20687 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20688 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20689 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20691 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20692 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20693 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20694 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20695 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20700 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20701 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20710 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20711 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20712 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20713 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20716 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20717 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20721 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20722 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20724 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20725 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20726 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20727 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20728 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20729 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20730 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20731 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20732 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20733 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20734 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20736 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20737 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20738 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20739 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20740 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20741 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20742 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20743 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20744 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20746 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20747 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20748 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20749 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20750 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20751 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20752 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20753 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20754 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20755 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20756 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20757 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20758 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20759 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20761 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20762 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20763 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20767 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20768 { NULL, NULL, 0, NULL }
20769 };
20770
20771
20772 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20773
20774 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20775 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20776 }
20777 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20778 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20779 }
20780 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20781 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20782 }
20783 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20784 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20785 }
20786 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20787 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20788 }
20789 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20790 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20791 }
20792 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20793 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20794 }
20795 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20796 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20797 }
20798 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20799 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20800 }
20801 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20802 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20803 }
20804 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20805 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20806 }
20807 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20808 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20809 }
20810 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20811 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20812 }
20813 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20814 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20815 }
20816 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20817 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20818 }
20819 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20820 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20821 }
20822 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20823 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20824 }
20825 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20826 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20827 }
20828 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20829 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20830 }
20831 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20832 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20833 }
20834 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20835 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20836 }
20837 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20838 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20839 }
20840 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20841 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20842 }
20843 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20844 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20845 }
20846 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20847 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20848 }
20849 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20850 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20851 }
20852 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20853 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20854 }
20855 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20856 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20857 }
20858 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20859 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20860 }
20861 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20862 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20863 }
20864 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20865 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20866 }
20867 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20868 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20869 }
20870 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20871 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20872 }
20873 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20874 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20875 }
20876 static void *_p_wxGridTo_p_wxPanel(void *x) {
20877 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20878 }
20879 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20880 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20881 }
20882 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20883 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20884 }
20885 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20886 return (void *)((wxPanel *) ((wxPyPanel *) x));
20887 }
20888 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20889 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20890 }
20891 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20892 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20893 }
20894 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20895 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20896 }
20897 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20898 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20899 }
20900 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20901 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20902 }
20903 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20904 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20905 }
20906 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20907 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20908 }
20909 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20910 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20911 }
20912 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20913 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20914 }
20915 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20916 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20917 }
20918 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20919 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20920 }
20921 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20922 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20923 }
20924 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20925 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20926 }
20927 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20928 return (void *)((wxWindow *) ((wxMenuBar *) x));
20929 }
20930 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20931 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20932 }
20933 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20934 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20935 }
20936 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20937 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20938 }
20939 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
20940 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
20941 }
20942 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20943 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20944 }
20945 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20946 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20947 }
20948 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20949 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20950 }
20951 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20952 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20953 }
20954 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20955 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20956 }
20957 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20958 return (void *)((wxWindow *) ((wxPanel *) x));
20959 }
20960 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20961 return (void *)((wxWindow *) ((wxStatusBar *) x));
20962 }
20963 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20964 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20965 }
20966 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20967 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
20968 }
20969 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20970 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20971 }
20972 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20973 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20974 }
20975 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20976 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20977 }
20978 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20979 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20980 }
20981 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20982 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20983 }
20984 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20985 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20986 }
20987 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20988 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20989 }
20990 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20991 return (void *)((wxWindow *) ((wxSashWindow *) x));
20992 }
20993 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20994 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20995 }
20996 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20997 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20998 }
20999 static void *_p_wxControlTo_p_wxWindow(void *x) {
21000 return (void *)((wxWindow *) ((wxControl *) x));
21001 }
21002 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21003 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21004 }
21005 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21006 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21007 }
21008 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21009 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21010 }
21011 static void *_p_wxGridTo_p_wxWindow(void *x) {
21012 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21013 }
21014 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21015 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21016 }
21017 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21018 return (void *)((wxWindow *) ((wxPyWindow *) x));
21019 }
21020 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21021 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21022 }
21023 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21024 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21025 }
21026 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21027 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21028 }
21029 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21030 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21031 }
21032 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21033 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21034 }
21035 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21036 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21037 }
21038 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21039 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21040 }
21041 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21042 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21043 }
21044 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21045 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21046 }
21047 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21048 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21049 }
21050 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21051 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21052 }
21053 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21054 return (void *)((wxControl *) ((wxControlWithItems *) x));
21055 }
21056 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21057 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21058 }
21059 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21060 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21061 }
21062 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21063 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21064 }
21065 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21066 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21067 }
21068 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21069 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21070 }
21071 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21072 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21073 }
21074 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21075 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21076 }
21077 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21078 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21079 }
21080 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21081 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21082 }
21083 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21084 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21085 }
21086 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21087 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21088 }
21089 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21090 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21091 }
21092 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21093 return (void *)((wxEvent *) ((wxPyEvent *) x));
21094 }
21095 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21096 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21097 }
21098 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21099 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21100 }
21101 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21102 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21103 }
21104 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21105 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21106 }
21107 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21108 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21109 }
21110 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21111 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21112 }
21113 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21114 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21115 }
21116 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21117 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21118 }
21119 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21120 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21121 }
21122 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21123 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21124 }
21125 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21126 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21127 }
21128 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21129 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21130 }
21131 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21132 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21133 }
21134 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21135 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21136 }
21137 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21139 }
21140 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21142 }
21143 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21144 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21145 }
21146 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21147 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21148 }
21149 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21150 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21151 }
21152 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21153 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21154 }
21155 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21156 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21157 }
21158 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21159 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21160 }
21161 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21162 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21163 }
21164 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21165 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21166 }
21167 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21168 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21169 }
21170 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21172 }
21173 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21174 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21175 }
21176 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21177 return (void *)((wxEvent *) ((wxShowEvent *) x));
21178 }
21179 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21180 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21181 }
21182 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21183 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21184 }
21185 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21186 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21187 }
21188 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21189 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21190 }
21191 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21192 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21193 }
21194 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21195 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21196 }
21197 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21198 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21199 }
21200 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21202 }
21203 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21205 }
21206 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21208 }
21209 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21211 }
21212 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) ((wxSizerItem *) x));
21214 }
21215 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21217 }
21218 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21220 }
21221 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21223 }
21224 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21226 }
21227 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21229 }
21230 static void *_p_wxSizerTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) ((wxSizer *) x));
21232 }
21233 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21235 }
21236 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21238 }
21239 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21241 }
21242 static void *_p_wxEventTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) ((wxEvent *) x));
21244 }
21245 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) ((wxFontData *) x));
21247 }
21248 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) ((wxPrintData *) x));
21250 }
21251 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21253 }
21254 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21256 }
21257 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21259 }
21260 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21262 }
21263 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21265 }
21266 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21268 }
21269 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21271 }
21272 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21274 }
21275 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21277 }
21278 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21280 }
21281 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21283 }
21284 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21286 }
21287 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21289 }
21290 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21292 }
21293 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21295 }
21296 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21298 }
21299 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21301 }
21302 static void *_p_wxControlTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21304 }
21305 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21307 }
21308 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21310 }
21311 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) ((wxFSFile *) x));
21313 }
21314 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21316 }
21317 static void *_p_wxGridTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21319 }
21320 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21322 }
21323 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21325 }
21326 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) ((wxColourData *) x));
21328 }
21329 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21331 }
21332 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21334 }
21335 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21337 }
21338 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21340 }
21341 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21343 }
21344 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21346 }
21347 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21349 }
21350 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21352 }
21353 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21355 }
21356 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21358 }
21359 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21361 }
21362 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21364 }
21365 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21367 }
21368 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21370 }
21371 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) ((wxPrinter *) x));
21373 }
21374 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) ((wxMenuItem *) x));
21376 }
21377 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21379 }
21380 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21382 }
21383 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21385 }
21386 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21388 }
21389 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21391 }
21392 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21394 }
21395 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21397 }
21398 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21400 }
21401 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21403 }
21404 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21406 }
21407 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21409 }
21410 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21412 }
21413 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21415 }
21416 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21418 }
21419 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21421 }
21422 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21424 }
21425 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21427 }
21428 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21430 }
21431 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21433 }
21434 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21436 }
21437 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) ((wxImageHandler *) x));
21439 }
21440 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21442 }
21443 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21445 }
21446 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) ((wxEvtHandler *) x));
21448 }
21449 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21451 }
21452 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21454 }
21455 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21457 }
21458 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21460 }
21461 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21463 }
21464 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21466 }
21467 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21469 }
21470 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21472 }
21473 static void *_p_wxImageTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) ((wxImage *) x));
21475 }
21476 static void *_p_wxFrameTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21478 }
21479 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) ((wxPyPrintout *) x));
21481 }
21482 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21484 }
21485 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21487 }
21488 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21490 }
21491 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21493 }
21494 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21496 }
21497 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21499 }
21500 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21502 }
21503 static void *_p_wxWindowTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21505 }
21506 static void *_p_wxMenuTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21508 }
21509 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21510 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21511 }
21512 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21513 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21514 }
21515 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21516 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21517 }
21518 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21519 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21520 }
21521 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21522 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21523 }
21524 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21525 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21526 }
21527 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21528 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21529 }
21530 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21531 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21532 }
21533 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21535 }
21536 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21538 }
21539 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21541 }
21542 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21544 }
21545 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21547 }
21548 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21550 }
21551 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) ((wxPrintPreview *) x));
21553 }
21554 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21556 }
21557 static void *_p_wxPanelTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21559 }
21560 static void *_p_wxDialogTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21562 }
21563 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21565 }
21566 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21568 }
21569 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21571 }
21572 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21574 }
21575 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) ((wxPrintDialog *) x));
21577 }
21578 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) ((wxFileSystem *) x));
21580 }
21581 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21583 }
21584 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21586 }
21587 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21588 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21589 }
21590 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21591 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21592 }
21593 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21594 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21595 }
21596 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21597 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21598 }
21599 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21600 return (void *)((wxObject *) ((wxGridTableBase *) x));
21601 }
21602 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21603 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21604 }
21605 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21607 }
21608 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21609 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21610 }
21611 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21612 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21613 }
21614 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21615 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21616 }
21617 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21618 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21619 }
21620 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21621 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21622 }
21623 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21625 }
21626 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21627 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21628 }
21629 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21630 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21631 }
21632 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21633 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21634 }
21635 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21636 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21637 }
21638 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21639 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21640 }
21641 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21642 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21643 }
21644 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21645 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21646 }
21647 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21648 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21649 }
21650 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21651 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21652 }
21653 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21654 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21655 }
21656 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21657 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21658 }
21659 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21660 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21661 }
21662 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21663 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21664 }
21665 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21666 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21667 }
21668 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21669 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21670 }
21671 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21672 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21673 }
21674 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21675 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21676 }
21677 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
21678 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21679 }
21680 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21681 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21682 }
21683 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21684 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21685 }
21686 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21687 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21688 }
21689 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21690 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21691 }
21692 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21693 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21694 }
21695 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21696 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21697 }
21698 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21699 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21700 }
21701 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21702 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21703 }
21704 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21705 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21706 }
21707 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21708 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21709 }
21710 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21711 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21712 }
21713 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21714 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21715 }
21716 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21717 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21718 }
21719 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21720 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21721 }
21722 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21723 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21724 }
21725 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21726 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21727 }
21728 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21729 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21730 }
21731 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21732 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21733 }
21734 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21735 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21736 }
21737 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21738 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21739 }
21740 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21741 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21742 }
21743 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21744 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21745 }
21746 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21747 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21748 }
21749 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21750 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21751 }
21752 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21753 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21754 }
21755 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21756 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21757 }
21758 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21759 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21760 }
21761 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21762 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21763 }
21764 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21765 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21766 }
21767 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21768 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21769 }
21770 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21771 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21772 }
21773 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21774 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21775 }
21776 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21777 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21778 }
21779 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21780 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21781 }
21782 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21783 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21784 }
21785 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21786 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21787 }
21788 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21789 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21790 }
21791 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21792 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21793 }
21794 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21795 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21796 }
21797 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21798 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21799 }
21800 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21801 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21802 }
21803 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21804 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21805 }
21806 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21807 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21808 }
21809 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21810 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21811 }
21812 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21813 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21814 }
21815 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21816 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21817 }
21818 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21819 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21820 }
21821 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21822 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21823 }
21824 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21825 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21826 }
21827 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21828 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21829 }
21830 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21831 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21832 }
21833 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21834 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21835 }
21836 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21837 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21838 }
21839 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21840 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21841 }
21842 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21843 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21844 }
21845 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21846 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21847 }
21848 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21849 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21850 }
21851 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21852 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21853 }
21854 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21855 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21856 }
21857 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21858 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21859 }
21860 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21861 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21862 }
21863 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21864 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21865 }
21866 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21867 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21868 }
21869 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21870 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21871 }
21872 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21873 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21874 }
21875 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21876 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21877 }
21878 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21879 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21880 }
21881 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21882 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21883 }
21884 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21885 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21886 }
21887 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21888 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21889 }
21890 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21891 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};
21892 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21893 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21894 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21895 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21896 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21897 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21898 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21899 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21900 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21901 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21902 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21903 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21904 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21905 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21906 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21907 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21908 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21909 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21910 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21911 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21912 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21913 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21914 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21915 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21916 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21917 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21918 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21919 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21920 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21921 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21922 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21923 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21924 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
21925 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21926 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21927 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21928 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21929 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21930 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21931 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21932 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21933 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21934 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21935 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21936 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21937 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21938 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21939 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21940 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21941 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21942 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21943 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21944 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21945 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21946 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21947 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21948 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21949 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21950 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21951 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21952 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21953 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
21954 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21955 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21956 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21957 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21958 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21959 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21960 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21961 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21962 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21963 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21964 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21965 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21966 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21967 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21968 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21969 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21970 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21971 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21972 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21973 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21974 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21975 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21976 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21978 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21979 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21980 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21983 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21985 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21986 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21987 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21993 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21994 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21995 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21996 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21997 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21998 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21999 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22000 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22001 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22002 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22003 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22004 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22005 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22006 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22007 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22008 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22009 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22010 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22011 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22012 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22013 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22014 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22015 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22016 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22017 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22018 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22019 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22020 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22021 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22022 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22023 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22024 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22025 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22026 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22027 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22028 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22029 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22030 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22031 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22032 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22033 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22034 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22035 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22036 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22037 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22038 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22039 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22040 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22041 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22042 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22043 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22044 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22045 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22046 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22047 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22048 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22049 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22050 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22051 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22052 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22053 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22054 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22055 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22056 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22057 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22058 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22059 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22060 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22061 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22062 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22063 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22064 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22065 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22066 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22067 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22068 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22069 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22070 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22071 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22072 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22073 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22074 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22075 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22076 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22077 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22078 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22079 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22080
22081 static swig_type_info *swig_type_initial[] = {
22082 &_swigt__p_char,
22083 &_swigt__p_form_ops_t,
22084 &_swigt__p_int,
22085 &_swigt__p_long,
22086 &_swigt__p_unsigned_char,
22087 &_swigt__p_unsigned_int,
22088 &_swigt__p_unsigned_long,
22089 &_swigt__p_wxANIHandler,
22090 &_swigt__p_wxAcceleratorTable,
22091 &_swigt__p_wxActivateEvent,
22092 &_swigt__p_wxArrayString,
22093 &_swigt__p_wxBMPHandler,
22094 &_swigt__p_wxBoxSizer,
22095 &_swigt__p_wxCURHandler,
22096 &_swigt__p_wxCalculateLayoutEvent,
22097 &_swigt__p_wxChildFocusEvent,
22098 &_swigt__p_wxClipboardTextEvent,
22099 &_swigt__p_wxCloseEvent,
22100 &_swigt__p_wxColour,
22101 &_swigt__p_wxColourData,
22102 &_swigt__p_wxColourDialog,
22103 &_swigt__p_wxCommandEvent,
22104 &_swigt__p_wxContextMenuEvent,
22105 &_swigt__p_wxControl,
22106 &_swigt__p_wxControlWithItems,
22107 &_swigt__p_wxDC,
22108 &_swigt__p_wxDateEvent,
22109 &_swigt__p_wxDialog,
22110 &_swigt__p_wxDirDialog,
22111 &_swigt__p_wxDisplayChangedEvent,
22112 &_swigt__p_wxDropFilesEvent,
22113 &_swigt__p_wxDuplexMode,
22114 &_swigt__p_wxEraseEvent,
22115 &_swigt__p_wxEvent,
22116 &_swigt__p_wxEvtHandler,
22117 &_swigt__p_wxFSFile,
22118 &_swigt__p_wxFileDialog,
22119 &_swigt__p_wxFileSystem,
22120 &_swigt__p_wxFindDialogEvent,
22121 &_swigt__p_wxFindReplaceData,
22122 &_swigt__p_wxFindReplaceDialog,
22123 &_swigt__p_wxFlexGridSizer,
22124 &_swigt__p_wxFocusEvent,
22125 &_swigt__p_wxFont,
22126 &_swigt__p_wxFontData,
22127 &_swigt__p_wxFontDialog,
22128 &_swigt__p_wxFrame,
22129 &_swigt__p_wxGBSizerItem,
22130 &_swigt__p_wxGIFHandler,
22131 &_swigt__p_wxGrid,
22132 &_swigt__p_wxGridBagSizer,
22133 &_swigt__p_wxGridCellAttr,
22134 &_swigt__p_wxGridCellAttrProvider,
22135 &_swigt__p_wxGridCellAutoWrapStringEditor,
22136 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22137 &_swigt__p_wxGridCellBoolEditor,
22138 &_swigt__p_wxGridCellBoolRenderer,
22139 &_swigt__p_wxGridCellChoiceEditor,
22140 &_swigt__p_wxGridCellCoords,
22141 &_swigt__p_wxGridCellDateTimeRenderer,
22142 &_swigt__p_wxGridCellEditor,
22143 &_swigt__p_wxGridCellEnumEditor,
22144 &_swigt__p_wxGridCellEnumRenderer,
22145 &_swigt__p_wxGridCellFloatEditor,
22146 &_swigt__p_wxGridCellFloatRenderer,
22147 &_swigt__p_wxGridCellNumberEditor,
22148 &_swigt__p_wxGridCellNumberRenderer,
22149 &_swigt__p_wxGridCellRenderer,
22150 &_swigt__p_wxGridCellStringRenderer,
22151 &_swigt__p_wxGridCellTextEditor,
22152 &_swigt__p_wxGridCellWorker,
22153 &_swigt__p_wxGridEditorCreatedEvent,
22154 &_swigt__p_wxGridEvent,
22155 &_swigt__p_wxGridRangeSelectEvent,
22156 &_swigt__p_wxGridSizeEvent,
22157 &_swigt__p_wxGridSizer,
22158 &_swigt__p_wxGridStringTable,
22159 &_swigt__p_wxGridTableBase,
22160 &_swigt__p_wxGridTableMessage,
22161 &_swigt__p_wxICOHandler,
22162 &_swigt__p_wxIconizeEvent,
22163 &_swigt__p_wxIdleEvent,
22164 &_swigt__p_wxImage,
22165 &_swigt__p_wxImageHandler,
22166 &_swigt__p_wxIndividualLayoutConstraint,
22167 &_swigt__p_wxInitDialogEvent,
22168 &_swigt__p_wxJPEGHandler,
22169 &_swigt__p_wxKeyEvent,
22170 &_swigt__p_wxLayoutAlgorithm,
22171 &_swigt__p_wxLayoutConstraints,
22172 &_swigt__p_wxMDIChildFrame,
22173 &_swigt__p_wxMDIClientWindow,
22174 &_swigt__p_wxMDIParentFrame,
22175 &_swigt__p_wxMaximizeEvent,
22176 &_swigt__p_wxMenu,
22177 &_swigt__p_wxMenuBar,
22178 &_swigt__p_wxMenuEvent,
22179 &_swigt__p_wxMenuItem,
22180 &_swigt__p_wxMessageDialog,
22181 &_swigt__p_wxMiniFrame,
22182 &_swigt__p_wxMouseCaptureChangedEvent,
22183 &_swigt__p_wxMouseCaptureLostEvent,
22184 &_swigt__p_wxMouseEvent,
22185 &_swigt__p_wxMoveEvent,
22186 &_swigt__p_wxMultiChoiceDialog,
22187 &_swigt__p_wxNavigationKeyEvent,
22188 &_swigt__p_wxNcPaintEvent,
22189 &_swigt__p_wxNotifyEvent,
22190 &_swigt__p_wxNumberEntryDialog,
22191 &_swigt__p_wxObject,
22192 &_swigt__p_wxPCXHandler,
22193 &_swigt__p_wxPNGHandler,
22194 &_swigt__p_wxPNMHandler,
22195 &_swigt__p_wxPageSetupDialog,
22196 &_swigt__p_wxPageSetupDialogData,
22197 &_swigt__p_wxPaintEvent,
22198 &_swigt__p_wxPaletteChangedEvent,
22199 &_swigt__p_wxPanel,
22200 &_swigt__p_wxPaperSize,
22201 &_swigt__p_wxPasswordEntryDialog,
22202 &_swigt__p_wxPen,
22203 &_swigt__p_wxPoint,
22204 &_swigt__p_wxPopupWindow,
22205 &_swigt__p_wxPreviewCanvas,
22206 &_swigt__p_wxPreviewControlBar,
22207 &_swigt__p_wxPreviewFrame,
22208 &_swigt__p_wxPrintData,
22209 &_swigt__p_wxPrintDialog,
22210 &_swigt__p_wxPrintDialogData,
22211 &_swigt__p_wxPrintPreview,
22212 &_swigt__p_wxPrinter,
22213 &_swigt__p_wxProgressDialog,
22214 &_swigt__p_wxPyApp,
22215 &_swigt__p_wxPyCommandEvent,
22216 &_swigt__p_wxPyEvent,
22217 &_swigt__p_wxPyGridCellAttrProvider,
22218 &_swigt__p_wxPyGridCellEditor,
22219 &_swigt__p_wxPyGridCellRenderer,
22220 &_swigt__p_wxPyGridTableBase,
22221 &_swigt__p_wxPyHtmlListBox,
22222 &_swigt__p_wxPyImageHandler,
22223 &_swigt__p_wxPyPanel,
22224 &_swigt__p_wxPyPopupTransientWindow,
22225 &_swigt__p_wxPyPreviewControlBar,
22226 &_swigt__p_wxPyPreviewFrame,
22227 &_swigt__p_wxPyPrintPreview,
22228 &_swigt__p_wxPyPrintout,
22229 &_swigt__p_wxPyScrolledWindow,
22230 &_swigt__p_wxPySizer,
22231 &_swigt__p_wxPyTaskBarIcon,
22232 &_swigt__p_wxPyVListBox,
22233 &_swigt__p_wxPyVScrolledWindow,
22234 &_swigt__p_wxPyValidator,
22235 &_swigt__p_wxPyWindow,
22236 &_swigt__p_wxQueryLayoutInfoEvent,
22237 &_swigt__p_wxQueryNewPaletteEvent,
22238 &_swigt__p_wxRect,
22239 &_swigt__p_wxSashEvent,
22240 &_swigt__p_wxSashLayoutWindow,
22241 &_swigt__p_wxSashWindow,
22242 &_swigt__p_wxScrollEvent,
22243 &_swigt__p_wxScrollWinEvent,
22244 &_swigt__p_wxScrolledWindow,
22245 &_swigt__p_wxSetCursorEvent,
22246 &_swigt__p_wxShowEvent,
22247 &_swigt__p_wxSingleChoiceDialog,
22248 &_swigt__p_wxSizeEvent,
22249 &_swigt__p_wxSizer,
22250 &_swigt__p_wxSizerItem,
22251 &_swigt__p_wxSplashScreen,
22252 &_swigt__p_wxSplashScreenWindow,
22253 &_swigt__p_wxSplitterEvent,
22254 &_swigt__p_wxSplitterWindow,
22255 &_swigt__p_wxStaticBoxSizer,
22256 &_swigt__p_wxStatusBar,
22257 &_swigt__p_wxStdDialogButtonSizer,
22258 &_swigt__p_wxString,
22259 &_swigt__p_wxSysColourChangedEvent,
22260 &_swigt__p_wxTIFFHandler,
22261 &_swigt__p_wxTaskBarIconEvent,
22262 &_swigt__p_wxTextEntryDialog,
22263 &_swigt__p_wxTipWindow,
22264 &_swigt__p_wxTopLevelWindow,
22265 &_swigt__p_wxUpdateUIEvent,
22266 &_swigt__p_wxValidator,
22267 &_swigt__p_wxVisualAttributes,
22268 &_swigt__p_wxWindow,
22269 &_swigt__p_wxWindowCreateEvent,
22270 &_swigt__p_wxWindowDestroyEvent,
22271 &_swigt__p_wxXPMHandler,
22272 };
22273
22274 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22275 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22276 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22277 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22278 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22279 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22280 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22281 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22282 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22283 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22284 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22285 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22286 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22287 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22288 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22289 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22290 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22291 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22292 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22293 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22294 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22295 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}};
22296 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22297 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}};
22298 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22299 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22300 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22301 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22302 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22303 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22304 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22305 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22306 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22307 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22308 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22309 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22310 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22311 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22312 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22313 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22314 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22315 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22316 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22317 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22318 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22319 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22320 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22321 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22322 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22323 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22324 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22325 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22326 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22327 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22328 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22329 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}};
22330 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22331 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22332 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22333 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22334 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22335 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22336 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22337 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22338 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22339 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22340 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22341 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22342 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22343 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22344 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22345 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22346 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22351 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22352 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22354 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22355 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22356 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22357 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22358 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22359 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22365 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22366 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22367 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22368 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22375 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}};
22376 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22379 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}};
22380 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22381 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22382 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22383 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22384 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}};
22385 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22386 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22387 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}};
22388 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22389 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22390 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22391 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22393 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22394 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}};
22395 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}};
22396 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}};
22397 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}};
22398 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22399 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22400 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22401 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22402 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22403 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}};
22404 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22405 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22406 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}};
22407 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22408 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22409 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22410 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22411 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22412 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22413 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22414 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22415 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22416 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22417 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22418 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22419 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22420 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22421 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22422 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22423 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22424 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22425 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22426 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22427 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22428 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22429 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22430 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22431 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22432 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22433 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22434 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22435 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22436 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22437 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22438 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22439 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22440 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22441 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22442 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22443 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22444 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22445 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22446 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22447 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22448 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22449 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22450 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}};
22451 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}};
22452 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22453 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22454 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22455 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22456 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22457 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22458 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22459 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22460 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}};
22461 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22462 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22463 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}};
22464
22465 static swig_cast_info *swig_cast_initial[] = {
22466 _swigc__p_char,
22467 _swigc__p_form_ops_t,
22468 _swigc__p_int,
22469 _swigc__p_long,
22470 _swigc__p_unsigned_char,
22471 _swigc__p_unsigned_int,
22472 _swigc__p_unsigned_long,
22473 _swigc__p_wxANIHandler,
22474 _swigc__p_wxAcceleratorTable,
22475 _swigc__p_wxActivateEvent,
22476 _swigc__p_wxArrayString,
22477 _swigc__p_wxBMPHandler,
22478 _swigc__p_wxBoxSizer,
22479 _swigc__p_wxCURHandler,
22480 _swigc__p_wxCalculateLayoutEvent,
22481 _swigc__p_wxChildFocusEvent,
22482 _swigc__p_wxClipboardTextEvent,
22483 _swigc__p_wxCloseEvent,
22484 _swigc__p_wxColour,
22485 _swigc__p_wxColourData,
22486 _swigc__p_wxColourDialog,
22487 _swigc__p_wxCommandEvent,
22488 _swigc__p_wxContextMenuEvent,
22489 _swigc__p_wxControl,
22490 _swigc__p_wxControlWithItems,
22491 _swigc__p_wxDC,
22492 _swigc__p_wxDateEvent,
22493 _swigc__p_wxDialog,
22494 _swigc__p_wxDirDialog,
22495 _swigc__p_wxDisplayChangedEvent,
22496 _swigc__p_wxDropFilesEvent,
22497 _swigc__p_wxDuplexMode,
22498 _swigc__p_wxEraseEvent,
22499 _swigc__p_wxEvent,
22500 _swigc__p_wxEvtHandler,
22501 _swigc__p_wxFSFile,
22502 _swigc__p_wxFileDialog,
22503 _swigc__p_wxFileSystem,
22504 _swigc__p_wxFindDialogEvent,
22505 _swigc__p_wxFindReplaceData,
22506 _swigc__p_wxFindReplaceDialog,
22507 _swigc__p_wxFlexGridSizer,
22508 _swigc__p_wxFocusEvent,
22509 _swigc__p_wxFont,
22510 _swigc__p_wxFontData,
22511 _swigc__p_wxFontDialog,
22512 _swigc__p_wxFrame,
22513 _swigc__p_wxGBSizerItem,
22514 _swigc__p_wxGIFHandler,
22515 _swigc__p_wxGrid,
22516 _swigc__p_wxGridBagSizer,
22517 _swigc__p_wxGridCellAttr,
22518 _swigc__p_wxGridCellAttrProvider,
22519 _swigc__p_wxGridCellAutoWrapStringEditor,
22520 _swigc__p_wxGridCellAutoWrapStringRenderer,
22521 _swigc__p_wxGridCellBoolEditor,
22522 _swigc__p_wxGridCellBoolRenderer,
22523 _swigc__p_wxGridCellChoiceEditor,
22524 _swigc__p_wxGridCellCoords,
22525 _swigc__p_wxGridCellDateTimeRenderer,
22526 _swigc__p_wxGridCellEditor,
22527 _swigc__p_wxGridCellEnumEditor,
22528 _swigc__p_wxGridCellEnumRenderer,
22529 _swigc__p_wxGridCellFloatEditor,
22530 _swigc__p_wxGridCellFloatRenderer,
22531 _swigc__p_wxGridCellNumberEditor,
22532 _swigc__p_wxGridCellNumberRenderer,
22533 _swigc__p_wxGridCellRenderer,
22534 _swigc__p_wxGridCellStringRenderer,
22535 _swigc__p_wxGridCellTextEditor,
22536 _swigc__p_wxGridCellWorker,
22537 _swigc__p_wxGridEditorCreatedEvent,
22538 _swigc__p_wxGridEvent,
22539 _swigc__p_wxGridRangeSelectEvent,
22540 _swigc__p_wxGridSizeEvent,
22541 _swigc__p_wxGridSizer,
22542 _swigc__p_wxGridStringTable,
22543 _swigc__p_wxGridTableBase,
22544 _swigc__p_wxGridTableMessage,
22545 _swigc__p_wxICOHandler,
22546 _swigc__p_wxIconizeEvent,
22547 _swigc__p_wxIdleEvent,
22548 _swigc__p_wxImage,
22549 _swigc__p_wxImageHandler,
22550 _swigc__p_wxIndividualLayoutConstraint,
22551 _swigc__p_wxInitDialogEvent,
22552 _swigc__p_wxJPEGHandler,
22553 _swigc__p_wxKeyEvent,
22554 _swigc__p_wxLayoutAlgorithm,
22555 _swigc__p_wxLayoutConstraints,
22556 _swigc__p_wxMDIChildFrame,
22557 _swigc__p_wxMDIClientWindow,
22558 _swigc__p_wxMDIParentFrame,
22559 _swigc__p_wxMaximizeEvent,
22560 _swigc__p_wxMenu,
22561 _swigc__p_wxMenuBar,
22562 _swigc__p_wxMenuEvent,
22563 _swigc__p_wxMenuItem,
22564 _swigc__p_wxMessageDialog,
22565 _swigc__p_wxMiniFrame,
22566 _swigc__p_wxMouseCaptureChangedEvent,
22567 _swigc__p_wxMouseCaptureLostEvent,
22568 _swigc__p_wxMouseEvent,
22569 _swigc__p_wxMoveEvent,
22570 _swigc__p_wxMultiChoiceDialog,
22571 _swigc__p_wxNavigationKeyEvent,
22572 _swigc__p_wxNcPaintEvent,
22573 _swigc__p_wxNotifyEvent,
22574 _swigc__p_wxNumberEntryDialog,
22575 _swigc__p_wxObject,
22576 _swigc__p_wxPCXHandler,
22577 _swigc__p_wxPNGHandler,
22578 _swigc__p_wxPNMHandler,
22579 _swigc__p_wxPageSetupDialog,
22580 _swigc__p_wxPageSetupDialogData,
22581 _swigc__p_wxPaintEvent,
22582 _swigc__p_wxPaletteChangedEvent,
22583 _swigc__p_wxPanel,
22584 _swigc__p_wxPaperSize,
22585 _swigc__p_wxPasswordEntryDialog,
22586 _swigc__p_wxPen,
22587 _swigc__p_wxPoint,
22588 _swigc__p_wxPopupWindow,
22589 _swigc__p_wxPreviewCanvas,
22590 _swigc__p_wxPreviewControlBar,
22591 _swigc__p_wxPreviewFrame,
22592 _swigc__p_wxPrintData,
22593 _swigc__p_wxPrintDialog,
22594 _swigc__p_wxPrintDialogData,
22595 _swigc__p_wxPrintPreview,
22596 _swigc__p_wxPrinter,
22597 _swigc__p_wxProgressDialog,
22598 _swigc__p_wxPyApp,
22599 _swigc__p_wxPyCommandEvent,
22600 _swigc__p_wxPyEvent,
22601 _swigc__p_wxPyGridCellAttrProvider,
22602 _swigc__p_wxPyGridCellEditor,
22603 _swigc__p_wxPyGridCellRenderer,
22604 _swigc__p_wxPyGridTableBase,
22605 _swigc__p_wxPyHtmlListBox,
22606 _swigc__p_wxPyImageHandler,
22607 _swigc__p_wxPyPanel,
22608 _swigc__p_wxPyPopupTransientWindow,
22609 _swigc__p_wxPyPreviewControlBar,
22610 _swigc__p_wxPyPreviewFrame,
22611 _swigc__p_wxPyPrintPreview,
22612 _swigc__p_wxPyPrintout,
22613 _swigc__p_wxPyScrolledWindow,
22614 _swigc__p_wxPySizer,
22615 _swigc__p_wxPyTaskBarIcon,
22616 _swigc__p_wxPyVListBox,
22617 _swigc__p_wxPyVScrolledWindow,
22618 _swigc__p_wxPyValidator,
22619 _swigc__p_wxPyWindow,
22620 _swigc__p_wxQueryLayoutInfoEvent,
22621 _swigc__p_wxQueryNewPaletteEvent,
22622 _swigc__p_wxRect,
22623 _swigc__p_wxSashEvent,
22624 _swigc__p_wxSashLayoutWindow,
22625 _swigc__p_wxSashWindow,
22626 _swigc__p_wxScrollEvent,
22627 _swigc__p_wxScrollWinEvent,
22628 _swigc__p_wxScrolledWindow,
22629 _swigc__p_wxSetCursorEvent,
22630 _swigc__p_wxShowEvent,
22631 _swigc__p_wxSingleChoiceDialog,
22632 _swigc__p_wxSizeEvent,
22633 _swigc__p_wxSizer,
22634 _swigc__p_wxSizerItem,
22635 _swigc__p_wxSplashScreen,
22636 _swigc__p_wxSplashScreenWindow,
22637 _swigc__p_wxSplitterEvent,
22638 _swigc__p_wxSplitterWindow,
22639 _swigc__p_wxStaticBoxSizer,
22640 _swigc__p_wxStatusBar,
22641 _swigc__p_wxStdDialogButtonSizer,
22642 _swigc__p_wxString,
22643 _swigc__p_wxSysColourChangedEvent,
22644 _swigc__p_wxTIFFHandler,
22645 _swigc__p_wxTaskBarIconEvent,
22646 _swigc__p_wxTextEntryDialog,
22647 _swigc__p_wxTipWindow,
22648 _swigc__p_wxTopLevelWindow,
22649 _swigc__p_wxUpdateUIEvent,
22650 _swigc__p_wxValidator,
22651 _swigc__p_wxVisualAttributes,
22652 _swigc__p_wxWindow,
22653 _swigc__p_wxWindowCreateEvent,
22654 _swigc__p_wxWindowDestroyEvent,
22655 _swigc__p_wxXPMHandler,
22656 };
22657
22658
22659 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22660
22661 static swig_const_info swig_const_table[] = {
22662 {0, 0, 0, 0.0, 0, 0}};
22663
22664 #ifdef __cplusplus
22665 }
22666 #endif
22667 /* -----------------------------------------------------------------------------
22668 * Type initialization:
22669 * This problem is tough by the requirement that no dynamic
22670 * memory is used. Also, since swig_type_info structures store pointers to
22671 * swig_cast_info structures and swig_cast_info structures store pointers back
22672 * to swig_type_info structures, we need some lookup code at initialization.
22673 * The idea is that swig generates all the structures that are needed.
22674 * The runtime then collects these partially filled structures.
22675 * The SWIG_InitializeModule function takes these initial arrays out of
22676 * swig_module, and does all the lookup, filling in the swig_module.types
22677 * array with the correct data and linking the correct swig_cast_info
22678 * structures together.
22679 *
22680 * The generated swig_type_info structures are assigned staticly to an initial
22681 * array. We just loop though that array, and handle each type individually.
22682 * First we lookup if this type has been already loaded, and if so, use the
22683 * loaded structure instead of the generated one. Then we have to fill in the
22684 * cast linked list. The cast data is initially stored in something like a
22685 * two-dimensional array. Each row corresponds to a type (there are the same
22686 * number of rows as there are in the swig_type_initial array). Each entry in
22687 * a column is one of the swig_cast_info structures for that type.
22688 * The cast_initial array is actually an array of arrays, because each row has
22689 * a variable number of columns. So to actually build the cast linked list,
22690 * we find the array of casts associated with the type, and loop through it
22691 * adding the casts to the list. The one last trick we need to do is making
22692 * sure the type pointer in the swig_cast_info struct is correct.
22693 *
22694 * First off, we lookup the cast->type name to see if it is already loaded.
22695 * There are three cases to handle:
22696 * 1) If the cast->type has already been loaded AND the type we are adding
22697 * casting info to has not been loaded (it is in this module), THEN we
22698 * replace the cast->type pointer with the type pointer that has already
22699 * been loaded.
22700 * 2) If BOTH types (the one we are adding casting info to, and the
22701 * cast->type) are loaded, THEN the cast info has already been loaded by
22702 * the previous module so we just ignore it.
22703 * 3) Finally, if cast->type has not already been loaded, then we add that
22704 * swig_cast_info to the linked list (because the cast->type) pointer will
22705 * be correct.
22706 * ----------------------------------------------------------------------------- */
22707
22708 #ifdef __cplusplus
22709 extern "C" {
22710 #if 0
22711 } /* c-mode */
22712 #endif
22713 #endif
22714
22715 #if 0
22716 #define SWIGRUNTIME_DEBUG
22717 #endif
22718
22719 SWIGRUNTIME void
22720 SWIG_InitializeModule(void *clientdata) {
22721 size_t i;
22722 swig_module_info *module_head;
22723 static int init_run = 0;
22724
22725 clientdata = clientdata;
22726
22727 if (init_run) return;
22728 init_run = 1;
22729
22730 /* Initialize the swig_module */
22731 swig_module.type_initial = swig_type_initial;
22732 swig_module.cast_initial = swig_cast_initial;
22733
22734 /* Try and load any already created modules */
22735 module_head = SWIG_GetModule(clientdata);
22736 if (module_head) {
22737 swig_module.next = module_head->next;
22738 module_head->next = &swig_module;
22739 } else {
22740 /* This is the first module loaded */
22741 swig_module.next = &swig_module;
22742 SWIG_SetModule(clientdata, &swig_module);
22743 }
22744
22745 /* Now work on filling in swig_module.types */
22746 #ifdef SWIGRUNTIME_DEBUG
22747 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22748 #endif
22749 for (i = 0; i < swig_module.size; ++i) {
22750 swig_type_info *type = 0;
22751 swig_type_info *ret;
22752 swig_cast_info *cast;
22753
22754 #ifdef SWIGRUNTIME_DEBUG
22755 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22756 #endif
22757
22758 /* if there is another module already loaded */
22759 if (swig_module.next != &swig_module) {
22760 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22761 }
22762 if (type) {
22763 /* Overwrite clientdata field */
22764 #ifdef SWIGRUNTIME_DEBUG
22765 printf("SWIG_InitializeModule: found type %s\n", type->name);
22766 #endif
22767 if (swig_module.type_initial[i]->clientdata) {
22768 type->clientdata = swig_module.type_initial[i]->clientdata;
22769 #ifdef SWIGRUNTIME_DEBUG
22770 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22771 #endif
22772 }
22773 } else {
22774 type = swig_module.type_initial[i];
22775 }
22776
22777 /* Insert casting types */
22778 cast = swig_module.cast_initial[i];
22779 while (cast->type) {
22780 /* Don't need to add information already in the list */
22781 ret = 0;
22782 #ifdef SWIGRUNTIME_DEBUG
22783 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22784 #endif
22785 if (swig_module.next != &swig_module) {
22786 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22787 #ifdef SWIGRUNTIME_DEBUG
22788 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22789 #endif
22790 }
22791 if (ret) {
22792 if (type == swig_module.type_initial[i]) {
22793 #ifdef SWIGRUNTIME_DEBUG
22794 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22795 #endif
22796 cast->type = ret;
22797 ret = 0;
22798 } else {
22799 /* Check for casting already in the list */
22800 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22801 #ifdef SWIGRUNTIME_DEBUG
22802 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22803 #endif
22804 if (!ocast) ret = 0;
22805 }
22806 }
22807
22808 if (!ret) {
22809 #ifdef SWIGRUNTIME_DEBUG
22810 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22811 #endif
22812 if (type->cast) {
22813 type->cast->prev = cast;
22814 cast->next = type->cast;
22815 }
22816 type->cast = cast;
22817 }
22818 cast++;
22819 }
22820 /* Set entry in modules->types array equal to the type */
22821 swig_module.types[i] = type;
22822 }
22823 swig_module.types[i] = 0;
22824
22825 #ifdef SWIGRUNTIME_DEBUG
22826 printf("**** SWIG_InitializeModule: Cast List ******\n");
22827 for (i = 0; i < swig_module.size; ++i) {
22828 int j = 0;
22829 swig_cast_info *cast = swig_module.cast_initial[i];
22830 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22831 while (cast->type) {
22832 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22833 cast++;
22834 ++j;
22835 }
22836 printf("---- Total casts: %d\n",j);
22837 }
22838 printf("**** SWIG_InitializeModule: Cast List ******\n");
22839 #endif
22840 }
22841
22842 /* This function will propagate the clientdata field of type to
22843 * any new swig_type_info structures that have been added into the list
22844 * of equivalent types. It is like calling
22845 * SWIG_TypeClientData(type, clientdata) a second time.
22846 */
22847 SWIGRUNTIME void
22848 SWIG_PropagateClientData(void) {
22849 size_t i;
22850 swig_cast_info *equiv;
22851 static int init_run = 0;
22852
22853 if (init_run) return;
22854 init_run = 1;
22855
22856 for (i = 0; i < swig_module.size; i++) {
22857 if (swig_module.types[i]->clientdata) {
22858 equiv = swig_module.types[i]->cast;
22859 while (equiv) {
22860 if (!equiv->converter) {
22861 if (equiv->type && !equiv->type->clientdata)
22862 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22863 }
22864 equiv = equiv->next;
22865 }
22866 }
22867 }
22868 }
22869
22870 #ifdef __cplusplus
22871 #if 0
22872 {
22873 /* c-mode */
22874 #endif
22875 }
22876 #endif
22877
22878
22879
22880 #ifdef __cplusplus
22881 extern "C" {
22882 #endif
22883
22884 /* Python-specific SWIG API */
22885 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22886 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22887 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22888
22889 /* -----------------------------------------------------------------------------
22890 * global variable support code.
22891 * ----------------------------------------------------------------------------- */
22892
22893 typedef struct swig_globalvar {
22894 char *name; /* Name of global variable */
22895 PyObject *(*get_attr)(void); /* Return the current value */
22896 int (*set_attr)(PyObject *); /* Set the value */
22897 struct swig_globalvar *next;
22898 } swig_globalvar;
22899
22900 typedef struct swig_varlinkobject {
22901 PyObject_HEAD
22902 swig_globalvar *vars;
22903 } swig_varlinkobject;
22904
22905 SWIGINTERN PyObject *
22906 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22907 return PyString_FromString("<Swig global variables>");
22908 }
22909
22910 SWIGINTERN PyObject *
22911 swig_varlink_str(swig_varlinkobject *v) {
22912 PyObject *str = PyString_FromString("(");
22913 swig_globalvar *var;
22914 for (var = v->vars; var; var=var->next) {
22915 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22916 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22917 }
22918 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22919 return str;
22920 }
22921
22922 SWIGINTERN int
22923 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22924 PyObject *str = swig_varlink_str(v);
22925 fprintf(fp,"Swig global variables ");
22926 fprintf(fp,"%s\n", PyString_AsString(str));
22927 Py_DECREF(str);
22928 return 0;
22929 }
22930
22931 SWIGINTERN void
22932 swig_varlink_dealloc(swig_varlinkobject *v) {
22933 swig_globalvar *var = v->vars;
22934 while (var) {
22935 swig_globalvar *n = var->next;
22936 free(var->name);
22937 free(var);
22938 var = n;
22939 }
22940 }
22941
22942 SWIGINTERN PyObject *
22943 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22944 PyObject *res = NULL;
22945 swig_globalvar *var = v->vars;
22946 while (var) {
22947 if (strcmp(var->name,n) == 0) {
22948 res = (*var->get_attr)();
22949 break;
22950 }
22951 var = var->next;
22952 }
22953 if (res == NULL && !PyErr_Occurred()) {
22954 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22955 }
22956 return res;
22957 }
22958
22959 SWIGINTERN int
22960 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22961 int res = 1;
22962 swig_globalvar *var = v->vars;
22963 while (var) {
22964 if (strcmp(var->name,n) == 0) {
22965 res = (*var->set_attr)(p);
22966 break;
22967 }
22968 var = var->next;
22969 }
22970 if (res == 1 && !PyErr_Occurred()) {
22971 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22972 }
22973 return res;
22974 }
22975
22976 SWIGINTERN PyTypeObject*
22977 swig_varlink_type(void) {
22978 static char varlink__doc__[] = "Swig var link object";
22979 static PyTypeObject varlink_type;
22980 static int type_init = 0;
22981 if (!type_init) {
22982 const PyTypeObject tmp
22983 = {
22984 PyObject_HEAD_INIT(NULL)
22985 0, /* Number of items in variable part (ob_size) */
22986 (char *)"swigvarlink", /* Type name (tp_name) */
22987 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22988 0, /* Itemsize (tp_itemsize) */
22989 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22990 (printfunc) swig_varlink_print, /* Print (tp_print) */
22991 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22992 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22993 0, /* tp_compare */
22994 (reprfunc) swig_varlink_repr, /* tp_repr */
22995 0, /* tp_as_number */
22996 0, /* tp_as_sequence */
22997 0, /* tp_as_mapping */
22998 0, /* tp_hash */
22999 0, /* tp_call */
23000 (reprfunc)swig_varlink_str, /* tp_str */
23001 0, /* tp_getattro */
23002 0, /* tp_setattro */
23003 0, /* tp_as_buffer */
23004 0, /* tp_flags */
23005 varlink__doc__, /* tp_doc */
23006 0, /* tp_traverse */
23007 0, /* tp_clear */
23008 0, /* tp_richcompare */
23009 0, /* tp_weaklistoffset */
23010 #if PY_VERSION_HEX >= 0x02020000
23011 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23012 #endif
23013 #if PY_VERSION_HEX >= 0x02030000
23014 0, /* tp_del */
23015 #endif
23016 #ifdef COUNT_ALLOCS
23017 0,0,0,0 /* tp_alloc -> tp_next */
23018 #endif
23019 };
23020 varlink_type = tmp;
23021 varlink_type.ob_type = &PyType_Type;
23022 type_init = 1;
23023 }
23024 return &varlink_type;
23025 }
23026
23027 /* Create a variable linking object for use later */
23028 SWIGINTERN PyObject *
23029 SWIG_Python_newvarlink(void) {
23030 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23031 if (result) {
23032 result->vars = 0;
23033 }
23034 return ((PyObject*) result);
23035 }
23036
23037 SWIGINTERN void
23038 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23039 swig_varlinkobject *v = (swig_varlinkobject *) p;
23040 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23041 if (gv) {
23042 size_t size = strlen(name)+1;
23043 gv->name = (char *)malloc(size);
23044 if (gv->name) {
23045 strncpy(gv->name,name,size);
23046 gv->get_attr = get_attr;
23047 gv->set_attr = set_attr;
23048 gv->next = v->vars;
23049 }
23050 }
23051 v->vars = gv;
23052 }
23053
23054 SWIGINTERN PyObject *
23055 SWIG_globals() {
23056 static PyObject *_SWIG_globals = 0;
23057 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23058 return _SWIG_globals;
23059 }
23060
23061 /* -----------------------------------------------------------------------------
23062 * constants/methods manipulation
23063 * ----------------------------------------------------------------------------- */
23064
23065 /* Install Constants */
23066 SWIGINTERN void
23067 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23068 PyObject *obj = 0;
23069 size_t i;
23070 for (i = 0; constants[i].type; ++i) {
23071 switch(constants[i].type) {
23072 case SWIG_PY_POINTER:
23073 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23074 break;
23075 case SWIG_PY_BINARY:
23076 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23077 break;
23078 default:
23079 obj = 0;
23080 break;
23081 }
23082 if (obj) {
23083 PyDict_SetItemString(d, constants[i].name, obj);
23084 Py_DECREF(obj);
23085 }
23086 }
23087 }
23088
23089 /* -----------------------------------------------------------------------------*/
23090 /* Fix SwigMethods to carry the callback ptrs when needed */
23091 /* -----------------------------------------------------------------------------*/
23092
23093 SWIGINTERN void
23094 SWIG_Python_FixMethods(PyMethodDef *methods,
23095 swig_const_info *const_table,
23096 swig_type_info **types,
23097 swig_type_info **types_initial) {
23098 size_t i;
23099 for (i = 0; methods[i].ml_name; ++i) {
23100 const char *c = methods[i].ml_doc;
23101 if (c && (c = strstr(c, "swig_ptr: "))) {
23102 int j;
23103 swig_const_info *ci = 0;
23104 const char *name = c + 10;
23105 for (j = 0; const_table[j].type; ++j) {
23106 if (strncmp(const_table[j].name, name,
23107 strlen(const_table[j].name)) == 0) {
23108 ci = &(const_table[j]);
23109 break;
23110 }
23111 }
23112 if (ci) {
23113 size_t shift = (ci->ptype) - types;
23114 swig_type_info *ty = types_initial[shift];
23115 size_t ldoc = (c - methods[i].ml_doc);
23116 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23117 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23118 if (ndoc) {
23119 char *buff = ndoc;
23120 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23121 if (ptr) {
23122 strncpy(buff, methods[i].ml_doc, ldoc);
23123 buff += ldoc;
23124 strncpy(buff, "swig_ptr: ", 10);
23125 buff += 10;
23126 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23127 methods[i].ml_doc = ndoc;
23128 }
23129 }
23130 }
23131 }
23132 }
23133 }
23134
23135 #ifdef __cplusplus
23136 }
23137 #endif
23138
23139 /* -----------------------------------------------------------------------------*
23140 * Partial Init method
23141 * -----------------------------------------------------------------------------*/
23142
23143 #ifdef __cplusplus
23144 extern "C"
23145 #endif
23146 SWIGEXPORT void SWIG_init(void) {
23147 PyObject *m, *d;
23148
23149 /* Fix SwigMethods to carry the callback ptrs when needed */
23150 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23151
23152 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23153 d = PyModule_GetDict(m);
23154
23155 SWIG_InitializeModule(0);
23156 SWIG_InstallConstants(d,swig_const_table);
23157
23158
23159 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23160 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23161 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23162 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23163 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23164 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23165 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23166 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23167 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23168 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23169 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23170 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23171 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23172 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23173 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23174 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23175 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23176 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23177 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23178 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23179 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23180 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23181 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23182 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23183 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23184 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23185 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23186 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23187 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23188 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23189 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23190 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23191 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23192 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23193 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23194 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23195 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23196 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23197 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23198 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23199 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23200 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23201 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23202 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23203 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23204 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23205 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23206 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23207 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23208 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23209 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23210 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23211 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23212 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23213 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23214 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23215
23216
23217 }
23218
wxWidgets (Impactor)