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


f2b9732f36940547479ee3e0b164789006527fb1
[wxWidgets.git] / wxPython / src / gtk / 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_wxMouseEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[103]
2570 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[107]
2574 #define SWIGTYPE_p_wxObject swig_types[108]
2575 #define SWIGTYPE_p_wxPCXHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNGHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNMHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPageSetupDialog swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[113]
2580 #define SWIGTYPE_p_wxPaintEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPanel swig_types[116]
2583 #define SWIGTYPE_p_wxPaperSize swig_types[117]
2584 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[118]
2585 #define SWIGTYPE_p_wxPoint swig_types[119]
2586 #define SWIGTYPE_p_wxPopupWindow swig_types[120]
2587 #define SWIGTYPE_p_wxPreviewCanvas swig_types[121]
2588 #define SWIGTYPE_p_wxPreviewControlBar swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewFrame swig_types[123]
2590 #define SWIGTYPE_p_wxPrintData swig_types[124]
2591 #define SWIGTYPE_p_wxPrintDialog swig_types[125]
2592 #define SWIGTYPE_p_wxPrintDialogData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintPreview swig_types[127]
2594 #define SWIGTYPE_p_wxPrinter swig_types[128]
2595 #define SWIGTYPE_p_wxProgressDialog swig_types[129]
2596 #define SWIGTYPE_p_wxPyApp swig_types[130]
2597 #define SWIGTYPE_p_wxPyCommandEvent swig_types[131]
2598 #define SWIGTYPE_p_wxPyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridTableBase swig_types[136]
2603 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[137]
2604 #define SWIGTYPE_p_wxPyImageHandler swig_types[138]
2605 #define SWIGTYPE_p_wxPyPanel swig_types[139]
2606 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[140]
2607 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[141]
2608 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[142]
2609 #define SWIGTYPE_p_wxPyPrintPreview swig_types[143]
2610 #define SWIGTYPE_p_wxPyPrintout swig_types[144]
2611 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[145]
2612 #define SWIGTYPE_p_wxPySizer swig_types[146]
2613 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[147]
2614 #define SWIGTYPE_p_wxPyVListBox swig_types[148]
2615 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[149]
2616 #define SWIGTYPE_p_wxPyValidator swig_types[150]
2617 #define SWIGTYPE_p_wxPyWindow swig_types[151]
2618 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[152]
2619 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[153]
2620 #define SWIGTYPE_p_wxRect swig_types[154]
2621 #define SWIGTYPE_p_wxSashEvent swig_types[155]
2622 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[156]
2623 #define SWIGTYPE_p_wxSashWindow swig_types[157]
2624 #define SWIGTYPE_p_wxScrollEvent swig_types[158]
2625 #define SWIGTYPE_p_wxScrollWinEvent swig_types[159]
2626 #define SWIGTYPE_p_wxScrolledWindow swig_types[160]
2627 #define SWIGTYPE_p_wxSetCursorEvent swig_types[161]
2628 #define SWIGTYPE_p_wxShowEvent swig_types[162]
2629 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[163]
2630 #define SWIGTYPE_p_wxSizeEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSizer swig_types[165]
2632 #define SWIGTYPE_p_wxSizerItem swig_types[166]
2633 #define SWIGTYPE_p_wxSplashScreen swig_types[167]
2634 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[168]
2635 #define SWIGTYPE_p_wxSplitterEvent swig_types[169]
2636 #define SWIGTYPE_p_wxSplitterWindow swig_types[170]
2637 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[171]
2638 #define SWIGTYPE_p_wxStatusBar swig_types[172]
2639 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[173]
2640 #define SWIGTYPE_p_wxString swig_types[174]
2641 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[175]
2642 #define SWIGTYPE_p_wxTIFFHandler swig_types[176]
2643 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[177]
2644 #define SWIGTYPE_p_wxTextEntryDialog swig_types[178]
2645 #define SWIGTYPE_p_wxTipWindow swig_types[179]
2646 #define SWIGTYPE_p_wxTopLevelWindow swig_types[180]
2647 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[181]
2648 #define SWIGTYPE_p_wxValidator swig_types[182]
2649 #define SWIGTYPE_p_wxVisualAttributes swig_types[183]
2650 #define SWIGTYPE_p_wxWindow swig_types[184]
2651 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[185]
2652 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[186]
2653 #define SWIGTYPE_p_wxXPMHandler swig_types[187]
2654 static swig_type_info *swig_types[189];
2655 static swig_module_info swig_module = {swig_types, 188, 0, 0, 0, 0};
2656 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2657 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2658
2659 /* -------- TYPES TABLE (END) -------- */
2660
2661 #if (PY_VERSION_HEX <= 0x02000000)
2662 # if !defined(SWIG_PYTHON_CLASSIC)
2663 # error "This python version requires to use swig with the '-classic' option"
2664 # endif
2665 #endif
2666 #if (PY_VERSION_HEX <= 0x02020000)
2667 # error "This python version requires to use swig with the '-nomodern' option"
2668 #endif
2669 #if (PY_VERSION_HEX <= 0x02020000)
2670 # error "This python version requires to use swig with the '-nomodernargs' option"
2671 #endif
2672 #ifndef METH_O
2673 # error "This python version requires to use swig with the '-nofastunpack' option"
2674 #endif
2675
2676 /*-----------------------------------------------
2677 @(target):= _grid.so
2678 ------------------------------------------------*/
2679 #define SWIG_init init_grid
2680
2681 #define SWIG_name "_grid"
2682
2683 #define SWIGVERSION 0x010329
2684
2685
2686 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2687 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2688
2689
2690 #include <stdexcept>
2691
2692
2693 namespace swig {
2694 class PyObject_ptr {
2695 protected:
2696 PyObject *_obj;
2697
2698 public:
2699 PyObject_ptr() :_obj(0)
2700 {
2701 }
2702
2703 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2704 {
2705 Py_XINCREF(_obj);
2706 }
2707
2708 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2709 {
2710 if (initial_ref) Py_XINCREF(_obj);
2711 }
2712
2713 PyObject_ptr & operator=(const PyObject_ptr& item)
2714 {
2715 Py_XINCREF(item._obj);
2716 Py_XDECREF(_obj);
2717 _obj = item._obj;
2718 return *this;
2719 }
2720
2721 ~PyObject_ptr()
2722 {
2723 Py_XDECREF(_obj);
2724 }
2725
2726 operator PyObject *() const
2727 {
2728 return _obj;
2729 }
2730
2731 PyObject *operator->() const
2732 {
2733 return _obj;
2734 }
2735 };
2736 }
2737
2738
2739 namespace swig {
2740 struct PyObject_var : PyObject_ptr {
2741 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2742
2743 PyObject_var & operator = (PyObject* obj)
2744 {
2745 Py_XDECREF(_obj);
2746 _obj = obj;
2747 return *this;
2748 }
2749 };
2750 }
2751
2752
2753 #include "wx/wxPython/wxPython.h"
2754 #include "wx/wxPython/pyclasses.h"
2755 #include "wx/wxPython/printfw.h"
2756
2757 #include <wx/grid.h>
2758 #include <wx/generic/gridctrl.h>
2759
2760
2761 static const wxString wxPyEmptyString(wxEmptyString);
2762 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2763 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2764
2765
2766 #define wxPyMake_TEMPLATE(TYPE) \
2767 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2768 PyObject* target = NULL; \
2769 if (source) { \
2770 /* Check if there is already a pointer to a Python object in the \
2771 OOR data that we can use. */ \
2772 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2773 if (data) { \
2774 target = data->m_obj; \
2775 if (target) \
2776 Py_INCREF(target); \
2777 } \
2778 /* Otherwise make a new wrapper for it the old fashioned way and \
2779 give it the OOR treatment */ \
2780 if (! target) { \
2781 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2782 if (target) \
2783 source->SetClientObject(new wxPyOORClientData(target)); \
2784 } \
2785 } else { /* source was NULL so return None. */ \
2786 Py_INCREF(Py_None); target = Py_None; \
2787 } \
2788 return target; \
2789 } \
2790
2791
2792 wxPyMake_TEMPLATE(wxGridCellRenderer)
2793 wxPyMake_TEMPLATE(wxGridCellEditor)
2794 wxPyMake_TEMPLATE(wxGridCellAttr)
2795 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2796 wxPyMake_TEMPLATE(wxGridTableBase)
2797
2798
2799
2800 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2801 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2802 wxGridCellAttr* rval = NULL; \
2803 bool found; \
2804 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2805 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2806 PyObject* ro; \
2807 wxGridCellAttr* ptr; \
2808 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2809 if (ro) { \
2810 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2811 rval = ptr; \
2812 Py_DECREF(ro); \
2813 } \
2814 } \
2815 wxPyEndBlockThreads(blocked); \
2816 if (! found) \
2817 rval = PCLASS::CBNAME(a, b, c); \
2818 return rval; \
2819 }
2820
2821
2822 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2823 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2824 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2825 bool found; \
2826 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2827 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2828 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2829 Py_DECREF(obj); \
2830 } \
2831 wxPyEndBlockThreads(blocked); \
2832 if (! found) \
2833 PCLASS::CBNAME(attr, a, b); \
2834 }
2835
2836
2837
2838 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2839 void CBNAME(wxGridCellAttr *attr, int val) { \
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2841 bool found; \
2842 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2843 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2844 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2845 Py_DECREF(obj); \
2846 } \
2847 wxPyEndBlockThreads(blocked); \
2848 if (! found) \
2849 PCLASS::CBNAME(attr, val); \
2850 }
2851
2852
2853
2854 #define PYCALLBACK_INT__pure(CBNAME) \
2855 int CBNAME() { \
2856 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2857 int rval = 0; \
2858 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2859 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2860 wxPyEndBlockThreads(blocked); \
2861 return rval; \
2862 }
2863
2864
2865
2866 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2867 bool CBNAME(int a, int b) { \
2868 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2869 bool rval = 0; \
2870 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2871 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2872 wxPyEndBlockThreads(blocked); \
2873 return rval; \
2874 }
2875
2876
2877 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2878 wxString CBNAME(int a, int b) { \
2879 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2880 wxString rval; \
2881 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2882 PyObject* ro; \
2883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2884 if (ro) { \
2885 rval = Py2wxString(ro); \
2886 Py_DECREF(ro); \
2887 } \
2888 } \
2889 wxPyEndBlockThreads(blocked); \
2890 return rval; \
2891 }
2892
2893
2894 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2895 void CBNAME(int a, int b, const wxString& c) { \
2896 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2897 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2898 PyObject* s = wx2PyString(c); \
2899 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2900 Py_DECREF(s); \
2901 } \
2902 wxPyEndBlockThreads(blocked); \
2903 }
2904
2905
2906 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2907 wxString CBNAME(int a, int b) { \
2908 bool found; \
2909 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2910 wxString rval; \
2911 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2912 PyObject* ro; \
2913 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2914 if (ro) { \
2915 rval = Py2wxString(ro); \
2916 Py_DECREF(ro); \
2917 } \
2918 } \
2919 wxPyEndBlockThreads(blocked); \
2920 if (! found) \
2921 rval = PCLASS::CBNAME(a, b); \
2922 return rval; \
2923 }
2924
2925
2926 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2927 bool CBNAME(int a, int b, const wxString& c) { \
2928 bool rval = 0; \
2929 bool found; \
2930 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2931 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2932 PyObject* s = wx2PyString(c); \
2933 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2934 Py_DECREF(s); \
2935 } \
2936 wxPyEndBlockThreads(blocked); \
2937 if (! found) \
2938 rval = PCLASS::CBNAME(a,b,c); \
2939 return rval; \
2940 }
2941
2942
2943
2944
2945 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2946 long CBNAME(int a, int b) { \
2947 long rval; \
2948 bool found; \
2949 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2950 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2951 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2952 wxPyEndBlockThreads(blocked); \
2953 if (! found) \
2954 rval = PCLASS::CBNAME(a,b); \
2955 return rval; \
2956 }
2957
2958
2959 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2960 bool CBNAME(int a, int b) { \
2961 bool rval = 0; \
2962 bool found; \
2963 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2964 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2965 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2966 wxPyEndBlockThreads(blocked); \
2967 if (! found) \
2968 rval = PCLASS::CBNAME(a,b); \
2969 return rval; \
2970 }
2971
2972
2973
2974 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2975 double CBNAME(int a, int b) { \
2976 bool found; \
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2978 double rval; \
2979 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2980 PyObject* ro; \
2981 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2982 if (ro) { \
2983 PyObject* str = PyObject_Str(ro); \
2984 rval = PyFloat_AsDouble(str); \
2985 Py_DECREF(ro); Py_DECREF(str); \
2986 } \
2987 } \
2988 wxPyEndBlockThreads(blocked); \
2989 if (! found) \
2990 rval = PCLASS::CBNAME(a, b); \
2991 return rval; \
2992 }
2993
2994
2995
2996 #define PYCALLBACK__(PCLASS, CBNAME) \
2997 void CBNAME() { \
2998 bool found; \
2999 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3000 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3001 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3002 wxPyEndBlockThreads(blocked); \
3003 if (! found) \
3004 PCLASS::CBNAME(); \
3005 }
3006
3007
3008
3009 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3010 bool CBNAME(size_t a, size_t b) { \
3011 bool rval = 0; \
3012 bool found; \
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3014 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3015 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3016 wxPyEndBlockThreads(blocked); \
3017 if (! found) \
3018 rval = PCLASS::CBNAME(a,b); \
3019 return rval; \
3020 }
3021
3022
3023
3024 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3025 bool CBNAME(size_t a) { \
3026 bool rval = 0; \
3027 bool found; \
3028 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3029 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3030 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3031 wxPyEndBlockThreads(blocked); \
3032 if (! found) \
3033 rval = PCLASS::CBNAME(a); \
3034 return rval; \
3035 }
3036
3037
3038 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3039 wxString CBNAME(int a) { \
3040 bool found; \
3041 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3042 wxString rval; \
3043 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3044 PyObject* ro; \
3045 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3046 if (ro) { \
3047 rval = Py2wxString(ro); \
3048 Py_DECREF(ro); \
3049 } \
3050 } \
3051 wxPyEndBlockThreads(blocked); \
3052 if (! found) \
3053 rval = PCLASS::CBNAME(a); \
3054 return rval; \
3055 }
3056
3057
3058 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3059 void CBNAME(int a, const wxString& c) { \
3060 bool found; \
3061 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3062 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3063 PyObject* s = wx2PyString(c); \
3064 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3065 Py_DECREF(s); \
3066 } \
3067 wxPyEndBlockThreads(blocked); \
3068 if (! found) \
3069 PCLASS::CBNAME(a,c); \
3070 }
3071
3072
3073
3074
3075 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3076 bool CBNAME() { \
3077 bool rval = 0; \
3078 bool found; \
3079 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3080 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3081 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3082 wxPyEndBlockThreads(blocked); \
3083 if (! found) \
3084 rval = PCLASS::CBNAME(); \
3085 return rval; \
3086 }
3087
3088
3089
3090 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3091 void CBNAME(size_t a, int b) { \
3092 bool found; \
3093 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3094 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3095 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3096 wxPyEndBlockThreads(blocked); \
3097 if (! found) \
3098 PCLASS::CBNAME(a,b); \
3099 }
3100
3101
3102
3103
3104 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3105 void CBNAME(int a, int b, long c) { \
3106 bool found; \
3107 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3108 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3109 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3110 wxPyEndBlockThreads(blocked); \
3111 if (! found) \
3112 PCLASS::CBNAME(a,b,c); \
3113 }
3114
3115
3116
3117
3118 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3119 void CBNAME(int a, int b, double c) { \
3120 bool found; \
3121 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3122 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3123 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3124 wxPyEndBlockThreads(blocked); \
3125 if (! found) \
3126 PCLASS::CBNAME(a,b,c); \
3127 }
3128
3129
3130
3131 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3132 void CBNAME(int a, int b, bool c) { \
3133 bool found; \
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3135 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3136 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3137 wxPyEndBlockThreads(blocked); \
3138 if (! found) \
3139 PCLASS::CBNAME(a,b,c); \
3140 }
3141
3142
3143
3144
3145
3146 SWIGINTERN swig_type_info*
3147 SWIG_pchar_descriptor()
3148 {
3149 static int init = 0;
3150 static swig_type_info* info = 0;
3151 if (!init) {
3152 info = SWIG_TypeQuery("_p_char");
3153 init = 1;
3154 }
3155 return info;
3156 }
3157
3158
3159 SWIGINTERNINLINE PyObject *
3160 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3161 {
3162 if (carray) {
3163 if (size > INT_MAX) {
3164 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3165 return pchar_descriptor ?
3166 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3167 } else {
3168 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3169 }
3170 } else {
3171 return SWIG_Py_Void();
3172 }
3173 }
3174
3175
3176 SWIGINTERNINLINE PyObject *
3177 SWIG_FromCharPtr(const char *cptr)
3178 {
3179 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3180 }
3181
3182
3183 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3184 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3185 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3186 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3187 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3188 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3189 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3190 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3191 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3192 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3193
3194
3195 #define SWIG_From_long PyInt_FromLong
3196
3197
3198 SWIGINTERNINLINE PyObject *
3199 SWIG_From_int (int value)
3200 {
3201 return SWIG_From_long (value);
3202 }
3203
3204 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3205 if (!self->GetClientObject())
3206 self->SetClientObject(new wxPyOORClientData(_self));
3207 }
3208 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3209 }
3210
3211 class wxPyGridCellRenderer : public wxGridCellRenderer
3212 {
3213 public:
3214 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3215
3216 // Implement Python callback aware virtual methods
3217 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3218 wxDC& dc, const wxRect& rect,
3219 int row, int col, bool isSelected) {
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3222 PyObject* go = wxPyMake_wxObject(&grid,false);
3223 PyObject* dco = wxPyMake_wxObject(&dc,false);
3224 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3225 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3226
3227 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3228 row, col, isSelected));
3229 Py_DECREF(go);
3230 Py_DECREF(ao);
3231 Py_DECREF(dco);
3232 Py_DECREF(ro);
3233 }
3234 wxPyEndBlockThreads(blocked);
3235 }
3236
3237 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3238 int row, int col) {
3239 wxSize rval;
3240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3241 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3242 PyObject* ro;
3243 wxSize* ptr;
3244 PyObject* go = wxPyMake_wxObject(&grid,false);
3245 PyObject* dco = wxPyMake_wxObject(&dc,false);
3246 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3247
3248 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3249 go, ao, dco,
3250 row, col));
3251 Py_DECREF(go);
3252 Py_DECREF(ao);
3253 Py_DECREF(dco);
3254
3255 if (ro) {
3256 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3257 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3258 rval = *ptr;
3259 }
3260 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3261 PyObject* o1 = PySequence_GetItem(ro, 0);
3262 PyObject* o2 = PySequence_GetItem(ro, 1);
3263 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3264 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3265 else
3266 PyErr_SetString(PyExc_TypeError, errmsg);
3267 Py_DECREF(o1);
3268 Py_DECREF(o2);
3269 }
3270 else {
3271 PyErr_SetString(PyExc_TypeError, errmsg);
3272 }
3273 Py_DECREF(ro);
3274 }
3275 }
3276 wxPyEndBlockThreads(blocked);
3277 return rval;
3278 }
3279
3280
3281 wxGridCellRenderer *Clone() const {
3282 wxGridCellRenderer* rval = NULL;
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3285 PyObject* ro;
3286 wxGridCellRenderer* ptr;
3287 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3288 if (ro) {
3289 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3290 rval = ptr;
3291 Py_DECREF(ro);
3292 }
3293 }
3294 wxPyEndBlockThreads(blocked);
3295 return rval;
3296 }
3297
3298 DEC_PYCALLBACK__STRING(SetParameters);
3299
3300 PYPRIVATE;
3301 };
3302
3303 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3304
3305
3306
3307 #include <limits.h>
3308 #ifndef LLONG_MIN
3309 # define LLONG_MIN LONG_LONG_MIN
3310 #endif
3311 #ifndef LLONG_MAX
3312 # define LLONG_MAX LONG_LONG_MAX
3313 #endif
3314 #ifndef ULLONG_MAX
3315 # define ULLONG_MAX ULONG_LONG_MAX
3316 #endif
3317
3318
3319 SWIGINTERN int
3320 SWIG_AsVal_long (PyObject* obj, long* val)
3321 {
3322 if (PyNumber_Check(obj)) {
3323 if (val) *val = PyInt_AsLong(obj);
3324 return SWIG_OK;
3325 }
3326 return SWIG_TypeError;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_int (PyObject * obj, int *val)
3332 {
3333 long v;
3334 int res = SWIG_AsVal_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v < INT_MIN || v > INT_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< int >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsVal_bool (PyObject *obj, bool *val)
3348 {
3349 if (obj == Py_True) {
3350 if (val) *val = true;
3351 return SWIG_OK;
3352 } else if (obj == Py_False) {
3353 if (val) *val = false;
3354 return SWIG_OK;
3355 } else {
3356 long v = 0;
3357 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3358 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3359 return res;
3360 }
3361 }
3362
3363
3364 class wxPyGridCellEditor : public wxGridCellEditor
3365 {
3366 public:
3367 wxPyGridCellEditor() : wxGridCellEditor() {}
3368
3369 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3371 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3372 PyObject* po = wxPyMake_wxObject(parent,false);
3373 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3374
3375 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3376 Py_DECREF(po);
3377 Py_DECREF(eo);
3378 }
3379 wxPyEndBlockThreads(blocked);
3380 }
3381
3382
3383 void BeginEdit(int row, int col, wxGrid* grid) {
3384 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3385 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3386 PyObject* go = wxPyMake_wxObject(grid,false);
3387 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3388 Py_DECREF(go);
3389 }
3390 wxPyEndBlockThreads(blocked);
3391 }
3392
3393
3394 bool EndEdit(int row, int col, wxGrid* grid) {
3395 bool rv = false;
3396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3397 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3398 PyObject* go = wxPyMake_wxObject(grid,false);
3399 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3400 Py_DECREF(go);
3401 }
3402 wxPyEndBlockThreads(blocked);
3403 return rv;
3404 }
3405
3406
3407 wxGridCellEditor* Clone() const {
3408 wxGridCellEditor* rval = NULL;
3409 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3410 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3411 PyObject* ro;
3412 wxGridCellEditor* ptr;
3413 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3414 if (ro) {
3415 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3416 rval = ptr;
3417 Py_DECREF(ro);
3418 }
3419 }
3420 wxPyEndBlockThreads(blocked);
3421 return rval;
3422 }
3423
3424
3425 void Show(bool show, wxGridCellAttr *attr) {
3426 bool found;
3427 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3428 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3429 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3430 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3431 Py_DECREF(ao);
3432 }
3433 wxPyEndBlockThreads(blocked);
3434 if (! found)
3435 wxGridCellEditor::Show(show, attr);
3436 }
3437
3438
3439 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3440 bool found;
3441 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3442 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3443 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3444 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3445
3446 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3447
3448 Py_DECREF(ro);
3449 Py_DECREF(ao);
3450 }
3451 wxPyEndBlockThreads(blocked);
3452 if (! found)
3453 wxGridCellEditor::PaintBackground(rectCell, attr);
3454 }
3455
3456
3457 DEC_PYCALLBACK___pure(Reset);
3458 DEC_PYCALLBACK__constany(SetSize, wxRect);
3459 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3460 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3461 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3462 DEC_PYCALLBACK__(StartingClick);
3463 DEC_PYCALLBACK__(Destroy);
3464 DEC_PYCALLBACK__STRING(SetParameters);
3465 DEC_PYCALLBACK_STRING__constpure(GetValue);
3466
3467 PYPRIVATE;
3468 };
3469
3470
3471 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3472 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3473 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3474 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3475 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3476 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3477 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3478 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3479 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3480
3481
3482 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3483 if (!self->GetClientObject())
3484 self->SetClientObject(new wxPyOORClientData(_self));
3485 }
3486 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3487 }
3488 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3489 if (!self->GetClientObject())
3490 self->SetClientObject(new wxPyOORClientData(_self));
3491 }
3492
3493 SWIGINTERN int
3494 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3495 {
3496 long v = 0;
3497 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3498 return SWIG_TypeError;
3499 }
3500 else if (val)
3501 *val = (unsigned long)v;
3502 return SWIG_OK;
3503 }
3504
3505
3506 SWIGINTERNINLINE int
3507 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3508 {
3509 unsigned long v;
3510 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3511 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3512 return res;
3513 }
3514
3515
3516 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3517 {
3518 public:
3519 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3520
3521 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3522 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3523 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3524 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3525
3526 PYPRIVATE;
3527 };
3528
3529 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3530 if (!self->GetClientObject())
3531 self->SetClientObject(new wxPyOORClientData(_self));
3532 }
3533
3534 #define SWIG_From_double PyFloat_FromDouble
3535
3536
3537 SWIGINTERN int
3538 SWIG_AsVal_double (PyObject *obj, double* val)
3539 {
3540 if (PyNumber_Check(obj)) {
3541 if (val) *val = PyFloat_AsDouble(obj);
3542 return SWIG_OK;
3543 }
3544 return SWIG_TypeError;
3545 }
3546
3547
3548 class wxPyGridTableBase : public wxGridTableBase
3549 {
3550 public:
3551 wxPyGridTableBase() : wxGridTableBase() {}
3552
3553 PYCALLBACK_INT__pure(GetNumberRows);
3554 PYCALLBACK_INT__pure(GetNumberCols);
3555 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3556 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3557 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3558 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3559 PYCALLBACK__(wxGridTableBase, Clear);
3560 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3561 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3562 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3563 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3564 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3565 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3566 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3567 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3568 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3569 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3570 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3571 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3572 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3573 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3574 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3575
3576
3577 wxString GetValue(int row, int col) {
3578 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3579 wxString rval;
3580 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3581 PyObject* ro;
3582 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3583 if (ro) {
3584 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3585 PyObject* old = ro;
3586 ro = PyObject_Str(ro);
3587 Py_DECREF(old);
3588 }
3589 rval = Py2wxString(ro);
3590 Py_DECREF(ro);
3591 }
3592 }
3593 wxPyEndBlockThreads(blocked);
3594 return rval;
3595 }
3596
3597 void SetValue(int row, int col, const wxString& val) {
3598 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3599 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3600 PyObject* s = wx2PyString(val);
3601 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3602 Py_DECREF(s);
3603 }
3604 wxPyEndBlockThreads(blocked);
3605 }
3606
3607
3608 // Map the Get/Set methods for the standard non-string types to
3609 // the GetValue and SetValue python methods.
3610 long GetValueAsLong( int row, int col ) {
3611 long rval = 0;
3612 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3613 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3614 PyObject* ro;
3615 PyObject* num;
3616 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3617 if (ro && PyNumber_Check(ro)) {
3618 num = PyNumber_Int(ro);
3619 if (num) {
3620 rval = PyInt_AsLong(num);
3621 Py_DECREF(num);
3622 }
3623 Py_DECREF(ro);
3624 }
3625 }
3626 wxPyEndBlockThreads(blocked);
3627 return rval;
3628 }
3629
3630 double GetValueAsDouble( int row, int col ) {
3631 double rval = 0.0;
3632 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3633 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3634 PyObject* ro;
3635 PyObject* num;
3636 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3637 if (ro && PyNumber_Check(ro)) {
3638 num = PyNumber_Float(ro);
3639 if (num) {
3640 rval = PyFloat_AsDouble(num);
3641 Py_DECREF(num);
3642 }
3643 Py_DECREF(ro);
3644 }
3645 }
3646 wxPyEndBlockThreads(blocked);
3647 return rval;
3648 }
3649
3650 bool GetValueAsBool( int row, int col ) {
3651 return (bool)GetValueAsLong(row, col);
3652 }
3653
3654 void SetValueAsLong( int row, int col, long value ) {
3655 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3656 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3657 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3658 }
3659 wxPyEndBlockThreads(blocked);
3660 }
3661
3662 void SetValueAsDouble( int row, int col, double value ) {
3663 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3664 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3665 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3666 }
3667 wxPyEndBlockThreads(blocked);
3668 }
3669
3670 void SetValueAsBool( int row, int col, bool value ) {
3671 SetValueAsLong( row, col, (long)value );
3672 }
3673
3674
3675 PYPRIVATE;
3676 };
3677
3678 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3679
3680 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3681
3682 if (source == Py_None) {
3683 **obj = wxGridCellCoords(-1,-1);
3684 return true;
3685 }
3686
3687 // If source is an object instance then it may already be the right type
3688 if (wxPySwigInstance_Check(source)) {
3689 wxGridCellCoords* ptr;
3690 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3691 goto error;
3692 *obj = ptr;
3693 return true;
3694 }
3695 // otherwise a 2-tuple of integers is expected
3696 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3697 PyObject* o1 = PySequence_GetItem(source, 0);
3698 PyObject* o2 = PySequence_GetItem(source, 1);
3699 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3700 Py_DECREF(o1);
3701 Py_DECREF(o2);
3702 goto error;
3703 }
3704 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3705 Py_DECREF(o1);
3706 Py_DECREF(o2);
3707 return true;
3708 }
3709
3710 error:
3711 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3712 return false;
3713 }
3714
3715
3716 bool wxGridCellCoords_typecheck(PyObject* source) {
3717 void* ptr;
3718
3719 if (wxPySwigInstance_Check(source) &&
3720 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3721 return true;
3722
3723 PyErr_Clear();
3724 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3725 return true;
3726
3727 return false;
3728 }
3729
3730
3731 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3732 {
3733 PyObject* list = PyList_New(0);
3734 size_t idx;
3735 for (idx = 0; idx < source.GetCount(); idx += 1) {
3736 wxGridCellCoords& coord = source.Item(idx);
3737 PyObject* tup = PyTuple_New(2);
3738 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3739 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3740 PyList_Append(list, tup);
3741 Py_DECREF(tup);
3742 }
3743 return list;
3744 }
3745
3746 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3747 wxGridCellCoords temp, *obj = &temp;
3748 if ( other == Py_None ) return false;
3749 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3750 PyErr_Clear();
3751 return false;
3752 }
3753 return self->operator==(*obj);
3754 }
3755 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3756 wxGridCellCoords temp, *obj = &temp;
3757 if ( other == Py_None ) return true;
3758 if ( ! wxGridCellCoords_helper(other, &obj)) {
3759 PyErr_Clear();
3760 return true;
3761 }
3762 return self->operator!=(*obj);
3763 }
3764 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3765 PyObject* tup = PyTuple_New(2);
3766 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3767 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3768 return tup;
3769 }
3770
3771 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3772
3773 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3774 wxGridCellCoords rv;
3775 self->XYToCell(x, y, rv);
3776 return rv;
3777 }
3778 #ifdef __cplusplus
3779 extern "C" {
3780 #endif
3781 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3782 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3783 return 1;
3784 }
3785
3786
3787 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3788 PyObject *pyobj = 0;
3789
3790 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3791 return pyobj;
3792 }
3793
3794
3795 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3796 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3797 return 1;
3798 }
3799
3800
3801 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3802 PyObject *pyobj = 0;
3803
3804 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3805 return pyobj;
3806 }
3807
3808
3809 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3810 PyObject *resultobj = 0;
3811 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3812 PyObject *arg2 = (PyObject *) 0 ;
3813 void *argp1 = 0 ;
3814 int res1 = 0 ;
3815 PyObject * obj0 = 0 ;
3816 PyObject * obj1 = 0 ;
3817 char * kwnames[] = {
3818 (char *) "self",(char *) "_self", NULL
3819 };
3820
3821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3823 if (!SWIG_IsOK(res1)) {
3824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3825 }
3826 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3827 arg2 = obj1;
3828 {
3829 PyThreadState* __tstate = wxPyBeginAllowThreads();
3830 wxGridCellWorker__setOORInfo(arg1,arg2);
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 resultobj = SWIG_Py_Void();
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3842 PyObject *resultobj = 0;
3843 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3844 void *argp1 = 0 ;
3845 int res1 = 0 ;
3846 PyObject *swig_obj[1] ;
3847
3848 if (!args) SWIG_fail;
3849 swig_obj[0] = args;
3850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3851 if (!SWIG_IsOK(res1)) {
3852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3853 }
3854 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3855 {
3856 PyThreadState* __tstate = wxPyBeginAllowThreads();
3857 delete_wxGridCellWorker(arg1);
3858
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 resultobj = SWIG_Py_Void();
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj = 0;
3871 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3872 wxString *arg2 = 0 ;
3873 void *argp1 = 0 ;
3874 int res1 = 0 ;
3875 bool temp2 = false ;
3876 PyObject * obj0 = 0 ;
3877 PyObject * obj1 = 0 ;
3878 char * kwnames[] = {
3879 (char *) "self",(char *) "params", NULL
3880 };
3881
3882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3884 if (!SWIG_IsOK(res1)) {
3885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3886 }
3887 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3888 {
3889 arg2 = wxString_in_helper(obj1);
3890 if (arg2 == NULL) SWIG_fail;
3891 temp2 = true;
3892 }
3893 {
3894 PyThreadState* __tstate = wxPyBeginAllowThreads();
3895 (arg1)->SetParameters((wxString const &)*arg2);
3896 wxPyEndAllowThreads(__tstate);
3897 if (PyErr_Occurred()) SWIG_fail;
3898 }
3899 resultobj = SWIG_Py_Void();
3900 {
3901 if (temp2)
3902 delete arg2;
3903 }
3904 return resultobj;
3905 fail:
3906 {
3907 if (temp2)
3908 delete arg2;
3909 }
3910 return NULL;
3911 }
3912
3913
3914 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3915 PyObject *resultobj = 0;
3916 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3917 void *argp1 = 0 ;
3918 int res1 = 0 ;
3919 PyObject *swig_obj[1] ;
3920
3921 if (!args) SWIG_fail;
3922 swig_obj[0] = args;
3923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3924 if (!SWIG_IsOK(res1)) {
3925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3926 }
3927 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 (arg1)->IncRef();
3931 wxPyEndAllowThreads(__tstate);
3932 if (PyErr_Occurred()) SWIG_fail;
3933 }
3934 resultobj = SWIG_Py_Void();
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3942 PyObject *resultobj = 0;
3943 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3944 void *argp1 = 0 ;
3945 int res1 = 0 ;
3946 PyObject *swig_obj[1] ;
3947
3948 if (!args) SWIG_fail;
3949 swig_obj[0] = args;
3950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3951 if (!SWIG_IsOK(res1)) {
3952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3953 }
3954 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3955 {
3956 PyThreadState* __tstate = wxPyBeginAllowThreads();
3957 (arg1)->DecRef();
3958 wxPyEndAllowThreads(__tstate);
3959 if (PyErr_Occurred()) SWIG_fail;
3960 }
3961 resultobj = SWIG_Py_Void();
3962 return resultobj;
3963 fail:
3964 return NULL;
3965 }
3966
3967
3968 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3969 PyObject *obj;
3970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3971 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3972 return SWIG_Py_Void();
3973 }
3974
3975 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3976 PyObject *obj;
3977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3978 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3979 return SWIG_Py_Void();
3980 }
3981
3982 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3983 PyObject *resultobj = 0;
3984 wxPyGridCellRenderer *result = 0 ;
3985
3986 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3987 {
3988 PyThreadState* __tstate = wxPyBeginAllowThreads();
3989 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3990 wxPyEndAllowThreads(__tstate);
3991 if (PyErr_Occurred()) SWIG_fail;
3992 }
3993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3994 return resultobj;
3995 fail:
3996 return NULL;
3997 }
3998
3999
4000 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4001 PyObject *resultobj = 0;
4002 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4003 PyObject *arg2 = (PyObject *) 0 ;
4004 PyObject *arg3 = (PyObject *) 0 ;
4005 void *argp1 = 0 ;
4006 int res1 = 0 ;
4007 PyObject * obj0 = 0 ;
4008 PyObject * obj1 = 0 ;
4009 PyObject * obj2 = 0 ;
4010 char * kwnames[] = {
4011 (char *) "self",(char *) "self",(char *) "_class", NULL
4012 };
4013
4014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4016 if (!SWIG_IsOK(res1)) {
4017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4018 }
4019 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4020 arg2 = obj1;
4021 arg3 = obj2;
4022 {
4023 PyThreadState* __tstate = wxPyBeginAllowThreads();
4024 (arg1)->_setCallbackInfo(arg2,arg3);
4025 wxPyEndAllowThreads(__tstate);
4026 if (PyErr_Occurred()) SWIG_fail;
4027 }
4028 resultobj = SWIG_Py_Void();
4029 return resultobj;
4030 fail:
4031 return NULL;
4032 }
4033
4034
4035 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj = 0;
4037 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4038 wxString *arg2 = 0 ;
4039 void *argp1 = 0 ;
4040 int res1 = 0 ;
4041 bool temp2 = false ;
4042 PyObject * obj0 = 0 ;
4043 PyObject * obj1 = 0 ;
4044 char * kwnames[] = {
4045 (char *) "self",(char *) "params", NULL
4046 };
4047
4048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4050 if (!SWIG_IsOK(res1)) {
4051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4052 }
4053 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4054 {
4055 arg2 = wxString_in_helper(obj1);
4056 if (arg2 == NULL) SWIG_fail;
4057 temp2 = true;
4058 }
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 (arg1)->SetParameters((wxString const &)*arg2);
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 resultobj = SWIG_Py_Void();
4066 {
4067 if (temp2)
4068 delete arg2;
4069 }
4070 return resultobj;
4071 fail:
4072 {
4073 if (temp2)
4074 delete arg2;
4075 }
4076 return NULL;
4077 }
4078
4079
4080 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4081 PyObject *obj;
4082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4083 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4084 return SWIG_Py_Void();
4085 }
4086
4087 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4088 return SWIG_Python_InitShadowInstance(args);
4089 }
4090
4091 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4092 PyObject *resultobj = 0;
4093 wxGridCellStringRenderer *result = 0 ;
4094
4095 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4096 {
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4099 wxPyEndAllowThreads(__tstate);
4100 if (PyErr_Occurred()) SWIG_fail;
4101 }
4102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4103 return resultobj;
4104 fail:
4105 return NULL;
4106 }
4107
4108
4109 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4110 PyObject *obj;
4111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4112 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4113 return SWIG_Py_Void();
4114 }
4115
4116 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4117 return SWIG_Python_InitShadowInstance(args);
4118 }
4119
4120 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4121 PyObject *resultobj = 0;
4122 wxGridCellNumberRenderer *result = 0 ;
4123
4124 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4139 PyObject *obj;
4140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4141 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4142 return SWIG_Py_Void();
4143 }
4144
4145 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4146 return SWIG_Python_InitShadowInstance(args);
4147 }
4148
4149 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = 0;
4151 int arg1 = (int) -1 ;
4152 int arg2 = (int) -1 ;
4153 wxGridCellFloatRenderer *result = 0 ;
4154 int val1 ;
4155 int ecode1 = 0 ;
4156 int val2 ;
4157 int ecode2 = 0 ;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char * kwnames[] = {
4161 (char *) "width",(char *) "precision", NULL
4162 };
4163
4164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4165 if (obj0) {
4166 ecode1 = SWIG_AsVal_int(obj0, &val1);
4167 if (!SWIG_IsOK(ecode1)) {
4168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4169 }
4170 arg1 = static_cast< int >(val1);
4171 }
4172 if (obj1) {
4173 ecode2 = SWIG_AsVal_int(obj1, &val2);
4174 if (!SWIG_IsOK(ecode2)) {
4175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4176 }
4177 arg2 = static_cast< int >(val2);
4178 }
4179 {
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4182 wxPyEndAllowThreads(__tstate);
4183 if (PyErr_Occurred()) SWIG_fail;
4184 }
4185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4186 return resultobj;
4187 fail:
4188 return NULL;
4189 }
4190
4191
4192 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4193 PyObject *resultobj = 0;
4194 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4195 int result;
4196 void *argp1 = 0 ;
4197 int res1 = 0 ;
4198 PyObject *swig_obj[1] ;
4199
4200 if (!args) SWIG_fail;
4201 swig_obj[0] = args;
4202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4203 if (!SWIG_IsOK(res1)) {
4204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4205 }
4206 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 resultobj = SWIG_From_int(static_cast< int >(result));
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj = 0;
4222 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4223 int arg2 ;
4224 void *argp1 = 0 ;
4225 int res1 = 0 ;
4226 int val2 ;
4227 int ecode2 = 0 ;
4228 PyObject * obj0 = 0 ;
4229 PyObject * obj1 = 0 ;
4230 char * kwnames[] = {
4231 (char *) "self",(char *) "width", NULL
4232 };
4233
4234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4236 if (!SWIG_IsOK(res1)) {
4237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4238 }
4239 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4240 ecode2 = SWIG_AsVal_int(obj1, &val2);
4241 if (!SWIG_IsOK(ecode2)) {
4242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4243 }
4244 arg2 = static_cast< int >(val2);
4245 {
4246 PyThreadState* __tstate = wxPyBeginAllowThreads();
4247 (arg1)->SetWidth(arg2);
4248 wxPyEndAllowThreads(__tstate);
4249 if (PyErr_Occurred()) SWIG_fail;
4250 }
4251 resultobj = SWIG_Py_Void();
4252 return resultobj;
4253 fail:
4254 return NULL;
4255 }
4256
4257
4258 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4259 PyObject *resultobj = 0;
4260 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4261 int result;
4262 void *argp1 = 0 ;
4263 int res1 = 0 ;
4264 PyObject *swig_obj[1] ;
4265
4266 if (!args) SWIG_fail;
4267 swig_obj[0] = args;
4268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4269 if (!SWIG_IsOK(res1)) {
4270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4271 }
4272 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = SWIG_From_int(static_cast< int >(result));
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4287 PyObject *resultobj = 0;
4288 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4289 int arg2 ;
4290 void *argp1 = 0 ;
4291 int res1 = 0 ;
4292 int val2 ;
4293 int ecode2 = 0 ;
4294 PyObject * obj0 = 0 ;
4295 PyObject * obj1 = 0 ;
4296 char * kwnames[] = {
4297 (char *) "self",(char *) "precision", NULL
4298 };
4299
4300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4302 if (!SWIG_IsOK(res1)) {
4303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4304 }
4305 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4306 ecode2 = SWIG_AsVal_int(obj1, &val2);
4307 if (!SWIG_IsOK(ecode2)) {
4308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4309 }
4310 arg2 = static_cast< int >(val2);
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 (arg1)->SetPrecision(arg2);
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 resultobj = SWIG_Py_Void();
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4325 PyObject *obj;
4326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4327 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4328 return SWIG_Py_Void();
4329 }
4330
4331 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4332 return SWIG_Python_InitShadowInstance(args);
4333 }
4334
4335 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4336 PyObject *resultobj = 0;
4337 wxGridCellBoolRenderer *result = 0 ;
4338
4339 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354 PyObject *obj;
4355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4356 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4357 return SWIG_Py_Void();
4358 }
4359
4360 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4361 return SWIG_Python_InitShadowInstance(args);
4362 }
4363
4364 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4365 PyObject *resultobj = 0;
4366 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4367 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4368 wxGridCellDateTimeRenderer *result = 0 ;
4369 PyObject * obj0 = 0 ;
4370 PyObject * obj1 = 0 ;
4371 char * kwnames[] = {
4372 (char *) "outformat",(char *) "informat", NULL
4373 };
4374
4375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4376 if (obj0) {
4377 {
4378 wxString* sptr = wxString_in_helper(obj0);
4379 if (sptr == NULL) SWIG_fail;
4380 arg1 = *sptr;
4381 delete sptr;
4382 }
4383 }
4384 if (obj1) {
4385 {
4386 wxString* sptr = wxString_in_helper(obj1);
4387 if (sptr == NULL) SWIG_fail;
4388 arg2 = *sptr;
4389 delete sptr;
4390 }
4391 }
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4406 PyObject *obj;
4407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4408 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4409 return SWIG_Py_Void();
4410 }
4411
4412 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 return SWIG_Python_InitShadowInstance(args);
4414 }
4415
4416 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4417 PyObject *resultobj = 0;
4418 wxString const &arg1_defvalue = wxPyEmptyString ;
4419 wxString *arg1 = (wxString *) &arg1_defvalue ;
4420 wxGridCellEnumRenderer *result = 0 ;
4421 bool temp1 = false ;
4422 PyObject * obj0 = 0 ;
4423 char * kwnames[] = {
4424 (char *) "choices", NULL
4425 };
4426
4427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4428 if (obj0) {
4429 {
4430 arg1 = wxString_in_helper(obj0);
4431 if (arg1 == NULL) SWIG_fail;
4432 temp1 = true;
4433 }
4434 }
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 return resultobj;
4447 fail:
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return NULL;
4453 }
4454
4455
4456 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *obj;
4458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4459 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4460 return SWIG_Py_Void();
4461 }
4462
4463 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4464 return SWIG_Python_InitShadowInstance(args);
4465 }
4466
4467 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4468 PyObject *resultobj = 0;
4469 wxGridCellAutoWrapStringRenderer *result = 0 ;
4470
4471 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4479 return resultobj;
4480 fail:
4481 return NULL;
4482 }
4483
4484
4485 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486 PyObject *obj;
4487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4488 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4489 return SWIG_Py_Void();
4490 }
4491
4492 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493 return SWIG_Python_InitShadowInstance(args);
4494 }
4495
4496 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4497 PyObject *resultobj = 0;
4498 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4499 bool result;
4500 void *argp1 = 0 ;
4501 int res1 = 0 ;
4502 PyObject *swig_obj[1] ;
4503
4504 if (!args) SWIG_fail;
4505 swig_obj[0] = args;
4506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4507 if (!SWIG_IsOK(res1)) {
4508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4509 }
4510 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = (bool)(arg1)->IsCreated();
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4527 PyObject *resultobj = 0;
4528 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4529 wxControl *result = 0 ;
4530 void *argp1 = 0 ;
4531 int res1 = 0 ;
4532 PyObject *swig_obj[1] ;
4533
4534 if (!args) SWIG_fail;
4535 swig_obj[0] = args;
4536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4537 if (!SWIG_IsOK(res1)) {
4538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4539 }
4540 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4541 {
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 result = (wxControl *)(arg1)->GetControl();
4544 wxPyEndAllowThreads(__tstate);
4545 if (PyErr_Occurred()) SWIG_fail;
4546 }
4547 {
4548 resultobj = wxPyMake_wxObject(result, 0);
4549 }
4550 return resultobj;
4551 fail:
4552 return NULL;
4553 }
4554
4555
4556 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4557 PyObject *resultobj = 0;
4558 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4559 wxControl *arg2 = (wxControl *) 0 ;
4560 void *argp1 = 0 ;
4561 int res1 = 0 ;
4562 void *argp2 = 0 ;
4563 int res2 = 0 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char * kwnames[] = {
4567 (char *) "self",(char *) "control", NULL
4568 };
4569
4570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4572 if (!SWIG_IsOK(res1)) {
4573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4574 }
4575 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4577 if (!SWIG_IsOK(res2)) {
4578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4579 }
4580 arg2 = reinterpret_cast< wxControl * >(argp2);
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 (arg1)->SetControl(arg2);
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 resultobj = SWIG_Py_Void();
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4597 wxGridCellAttr *result = 0 ;
4598 void *argp1 = 0 ;
4599 int res1 = 0 ;
4600 PyObject *swig_obj[1] ;
4601
4602 if (!args) SWIG_fail;
4603 swig_obj[0] = args;
4604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4605 if (!SWIG_IsOK(res1)) {
4606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4607 }
4608 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 {
4616 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4617 }
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj = 0;
4626 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4627 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4628 void *argp1 = 0 ;
4629 int res1 = 0 ;
4630 void *argp2 = 0 ;
4631 int res2 = 0 ;
4632 PyObject * obj0 = 0 ;
4633 PyObject * obj1 = 0 ;
4634 char * kwnames[] = {
4635 (char *) "self",(char *) "attr", NULL
4636 };
4637
4638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4642 }
4643 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4645 if (!SWIG_IsOK(res2)) {
4646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4647 }
4648 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4649 {
4650 PyThreadState* __tstate = wxPyBeginAllowThreads();
4651 (arg1)->SetCellAttr(arg2);
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_Py_Void();
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = 0;
4664 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4665 wxWindow *arg2 = (wxWindow *) 0 ;
4666 int arg3 ;
4667 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4668 void *argp1 = 0 ;
4669 int res1 = 0 ;
4670 void *argp2 = 0 ;
4671 int res2 = 0 ;
4672 int val3 ;
4673 int ecode3 = 0 ;
4674 void *argp4 = 0 ;
4675 int res4 = 0 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 PyObject * obj2 = 0 ;
4679 PyObject * obj3 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4688 }
4689 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4691 if (!SWIG_IsOK(res2)) {
4692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4693 }
4694 arg2 = reinterpret_cast< wxWindow * >(argp2);
4695 ecode3 = SWIG_AsVal_int(obj2, &val3);
4696 if (!SWIG_IsOK(ecode3)) {
4697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4698 }
4699 arg3 = static_cast< int >(val3);
4700 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4701 if (!SWIG_IsOK(res4)) {
4702 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4703 }
4704 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4705 {
4706 PyThreadState* __tstate = wxPyBeginAllowThreads();
4707 (arg1)->Create(arg2,arg3,arg4);
4708 wxPyEndAllowThreads(__tstate);
4709 if (PyErr_Occurred()) SWIG_fail;
4710 }
4711 resultobj = SWIG_Py_Void();
4712 return resultobj;
4713 fail:
4714 return NULL;
4715 }
4716
4717
4718 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4719 PyObject *resultobj = 0;
4720 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4721 int arg2 ;
4722 int arg3 ;
4723 wxGrid *arg4 = (wxGrid *) 0 ;
4724 void *argp1 = 0 ;
4725 int res1 = 0 ;
4726 int val2 ;
4727 int ecode2 = 0 ;
4728 int val3 ;
4729 int ecode3 = 0 ;
4730 void *argp4 = 0 ;
4731 int res4 = 0 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 PyObject * obj2 = 0 ;
4735 PyObject * obj3 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4744 }
4745 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4746 ecode2 = SWIG_AsVal_int(obj1, &val2);
4747 if (!SWIG_IsOK(ecode2)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4749 }
4750 arg2 = static_cast< int >(val2);
4751 ecode3 = SWIG_AsVal_int(obj2, &val3);
4752 if (!SWIG_IsOK(ecode3)) {
4753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4754 }
4755 arg3 = static_cast< int >(val3);
4756 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4757 if (!SWIG_IsOK(res4)) {
4758 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4759 }
4760 arg4 = reinterpret_cast< wxGrid * >(argp4);
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 (arg1)->BeginEdit(arg2,arg3,arg4);
4764 wxPyEndAllowThreads(__tstate);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 resultobj = SWIG_Py_Void();
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4777 int arg2 ;
4778 int arg3 ;
4779 wxGrid *arg4 = (wxGrid *) 0 ;
4780 bool result;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 int val2 ;
4784 int ecode2 = 0 ;
4785 int val3 ;
4786 int ecode3 = 0 ;
4787 void *argp4 = 0 ;
4788 int res4 = 0 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 PyObject * obj2 = 0 ;
4792 PyObject * obj3 = 0 ;
4793 char * kwnames[] = {
4794 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4795 };
4796
4797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4801 }
4802 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4803 ecode2 = SWIG_AsVal_int(obj1, &val2);
4804 if (!SWIG_IsOK(ecode2)) {
4805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4806 }
4807 arg2 = static_cast< int >(val2);
4808 ecode3 = SWIG_AsVal_int(obj2, &val3);
4809 if (!SWIG_IsOK(ecode3)) {
4810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4811 }
4812 arg3 = static_cast< int >(val3);
4813 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4814 if (!SWIG_IsOK(res4)) {
4815 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4816 }
4817 arg4 = reinterpret_cast< wxGrid * >(argp4);
4818 {
4819 PyThreadState* __tstate = wxPyBeginAllowThreads();
4820 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4821 wxPyEndAllowThreads(__tstate);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 {
4825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4826 }
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4834 PyObject *resultobj = 0;
4835 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4836 void *argp1 = 0 ;
4837 int res1 = 0 ;
4838 PyObject *swig_obj[1] ;
4839
4840 if (!args) SWIG_fail;
4841 swig_obj[0] = args;
4842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4843 if (!SWIG_IsOK(res1)) {
4844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4845 }
4846 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4847 {
4848 PyThreadState* __tstate = wxPyBeginAllowThreads();
4849 (arg1)->Reset();
4850 wxPyEndAllowThreads(__tstate);
4851 if (PyErr_Occurred()) SWIG_fail;
4852 }
4853 resultobj = SWIG_Py_Void();
4854 return resultobj;
4855 fail:
4856 return NULL;
4857 }
4858
4859
4860 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4861 PyObject *resultobj = 0;
4862 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4863 wxGridCellEditor *result = 0 ;
4864 void *argp1 = 0 ;
4865 int res1 = 0 ;
4866 PyObject *swig_obj[1] ;
4867
4868 if (!args) SWIG_fail;
4869 swig_obj[0] = args;
4870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4873 }
4874 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4875 {
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4878 wxPyEndAllowThreads(__tstate);
4879 if (PyErr_Occurred()) SWIG_fail;
4880 }
4881 {
4882 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4883 }
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4891 PyObject *resultobj = 0;
4892 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4893 wxRect *arg2 = 0 ;
4894 void *argp1 = 0 ;
4895 int res1 = 0 ;
4896 wxRect temp2 ;
4897 PyObject * obj0 = 0 ;
4898 PyObject * obj1 = 0 ;
4899 char * kwnames[] = {
4900 (char *) "self",(char *) "rect", NULL
4901 };
4902
4903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4905 if (!SWIG_IsOK(res1)) {
4906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4907 }
4908 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4909 {
4910 arg2 = &temp2;
4911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4912 }
4913 {
4914 PyThreadState* __tstate = wxPyBeginAllowThreads();
4915 (arg1)->SetSize((wxRect const &)*arg2);
4916 wxPyEndAllowThreads(__tstate);
4917 if (PyErr_Occurred()) SWIG_fail;
4918 }
4919 resultobj = SWIG_Py_Void();
4920 return resultobj;
4921 fail:
4922 return NULL;
4923 }
4924
4925
4926 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4927 PyObject *resultobj = 0;
4928 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4929 bool arg2 ;
4930 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4931 void *argp1 = 0 ;
4932 int res1 = 0 ;
4933 bool val2 ;
4934 int ecode2 = 0 ;
4935 void *argp3 = 0 ;
4936 int res3 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "show",(char *) "attr", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4948 }
4949 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4951 if (!SWIG_IsOK(ecode2)) {
4952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4953 }
4954 arg2 = static_cast< bool >(val2);
4955 if (obj2) {
4956 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4957 if (!SWIG_IsOK(res3)) {
4958 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4959 }
4960 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4961 }
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 (arg1)->Show(arg2,arg3);
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4978 wxRect *arg2 = 0 ;
4979 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4980 void *argp1 = 0 ;
4981 int res1 = 0 ;
4982 wxRect temp2 ;
4983 void *argp3 = 0 ;
4984 int res3 = 0 ;
4985 PyObject * obj0 = 0 ;
4986 PyObject * obj1 = 0 ;
4987 PyObject * obj2 = 0 ;
4988 char * kwnames[] = {
4989 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4990 };
4991
4992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4994 if (!SWIG_IsOK(res1)) {
4995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4996 }
4997 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4998 {
4999 arg2 = &temp2;
5000 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5001 }
5002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5003 if (!SWIG_IsOK(res3)) {
5004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5005 }
5006 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5023 wxKeyEvent *arg2 = 0 ;
5024 bool result;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 void *argp2 = 0 ;
5028 int res2 = 0 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char * kwnames[] = {
5032 (char *) "self",(char *) "event", NULL
5033 };
5034
5035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5037 if (!SWIG_IsOK(res1)) {
5038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5039 }
5040 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5041 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5042 if (!SWIG_IsOK(res2)) {
5043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5044 }
5045 if (!argp2) {
5046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5047 }
5048 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5049 {
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 {
5056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5057 }
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj = 0;
5066 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5067 wxKeyEvent *arg2 = 0 ;
5068 void *argp1 = 0 ;
5069 int res1 = 0 ;
5070 void *argp2 = 0 ;
5071 int res2 = 0 ;
5072 PyObject * obj0 = 0 ;
5073 PyObject * obj1 = 0 ;
5074 char * kwnames[] = {
5075 (char *) "self",(char *) "event", NULL
5076 };
5077
5078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5080 if (!SWIG_IsOK(res1)) {
5081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5082 }
5083 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5084 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5085 if (!SWIG_IsOK(res2)) {
5086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5087 }
5088 if (!argp2) {
5089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5090 }
5091 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 (arg1)->StartingKey(*arg2);
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 resultobj = SWIG_Py_Void();
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5108 void *argp1 = 0 ;
5109 int res1 = 0 ;
5110 PyObject *swig_obj[1] ;
5111
5112 if (!args) SWIG_fail;
5113 swig_obj[0] = args;
5114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5115 if (!SWIG_IsOK(res1)) {
5116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5117 }
5118 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5119 {
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 (arg1)->StartingClick();
5122 wxPyEndAllowThreads(__tstate);
5123 if (PyErr_Occurred()) SWIG_fail;
5124 }
5125 resultobj = SWIG_Py_Void();
5126 return resultobj;
5127 fail:
5128 return NULL;
5129 }
5130
5131
5132 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5133 PyObject *resultobj = 0;
5134 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5135 wxKeyEvent *arg2 = 0 ;
5136 void *argp1 = 0 ;
5137 int res1 = 0 ;
5138 void *argp2 = 0 ;
5139 int res2 = 0 ;
5140 PyObject * obj0 = 0 ;
5141 PyObject * obj1 = 0 ;
5142 char * kwnames[] = {
5143 (char *) "self",(char *) "event", NULL
5144 };
5145
5146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5148 if (!SWIG_IsOK(res1)) {
5149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5150 }
5151 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5153 if (!SWIG_IsOK(res2)) {
5154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5155 }
5156 if (!argp2) {
5157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5158 }
5159 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 (arg1)->HandleReturn(*arg2);
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 resultobj = SWIG_Py_Void();
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5174 PyObject *resultobj = 0;
5175 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5176 void *argp1 = 0 ;
5177 int res1 = 0 ;
5178 PyObject *swig_obj[1] ;
5179
5180 if (!args) SWIG_fail;
5181 swig_obj[0] = args;
5182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5183 if (!SWIG_IsOK(res1)) {
5184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5185 }
5186 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5187 {
5188 PyThreadState* __tstate = wxPyBeginAllowThreads();
5189 (arg1)->Destroy();
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5201 PyObject *obj;
5202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5203 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5204 return SWIG_Py_Void();
5205 }
5206
5207 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5208 PyObject *resultobj = 0;
5209 wxPyGridCellEditor *result = 0 ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5215 wxPyEndAllowThreads(__tstate);
5216 if (PyErr_Occurred()) SWIG_fail;
5217 }
5218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj = 0;
5227 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5228 PyObject *arg2 = (PyObject *) 0 ;
5229 PyObject *arg3 = (PyObject *) 0 ;
5230 void *argp1 = 0 ;
5231 int res1 = 0 ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 PyObject * obj2 = 0 ;
5235 char * kwnames[] = {
5236 (char *) "self",(char *) "self",(char *) "_class", NULL
5237 };
5238
5239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5243 }
5244 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5245 arg2 = obj1;
5246 arg3 = obj2;
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 (arg1)->_setCallbackInfo(arg2,arg3);
5250 wxPyEndAllowThreads(__tstate);
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 resultobj = SWIG_Py_Void();
5254 return resultobj;
5255 fail:
5256 return NULL;
5257 }
5258
5259
5260 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5261 PyObject *resultobj = 0;
5262 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5263 wxString *arg2 = 0 ;
5264 void *argp1 = 0 ;
5265 int res1 = 0 ;
5266 bool temp2 = false ;
5267 PyObject * obj0 = 0 ;
5268 PyObject * obj1 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "self",(char *) "params", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5277 }
5278 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5279 {
5280 arg2 = wxString_in_helper(obj1);
5281 if (arg2 == NULL) SWIG_fail;
5282 temp2 = true;
5283 }
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 (arg1)->SetParameters((wxString const &)*arg2);
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_Py_Void();
5291 {
5292 if (temp2)
5293 delete arg2;
5294 }
5295 return resultobj;
5296 fail:
5297 {
5298 if (temp2)
5299 delete arg2;
5300 }
5301 return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5306 PyObject *obj;
5307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5308 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5309 return SWIG_Py_Void();
5310 }
5311
5312 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 return SWIG_Python_InitShadowInstance(args);
5314 }
5315
5316 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5317 PyObject *resultobj = 0;
5318 wxGridCellTextEditor *result = 0 ;
5319
5320 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5337 wxString result;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 PyObject *swig_obj[1] ;
5341
5342 if (!args) SWIG_fail;
5343 swig_obj[0] = args;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5347 }
5348 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = (arg1)->GetValue();
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *obj;
5370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5371 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5372 return SWIG_Py_Void();
5373 }
5374
5375 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5376 return SWIG_Python_InitShadowInstance(args);
5377 }
5378
5379 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5380 PyObject *resultobj = 0;
5381 int arg1 = (int) -1 ;
5382 int arg2 = (int) -1 ;
5383 wxGridCellNumberEditor *result = 0 ;
5384 int val1 ;
5385 int ecode1 = 0 ;
5386 int val2 ;
5387 int ecode2 = 0 ;
5388 PyObject * obj0 = 0 ;
5389 PyObject * obj1 = 0 ;
5390 char * kwnames[] = {
5391 (char *) "min",(char *) "max", NULL
5392 };
5393
5394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5395 if (obj0) {
5396 ecode1 = SWIG_AsVal_int(obj0, &val1);
5397 if (!SWIG_IsOK(ecode1)) {
5398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5399 }
5400 arg1 = static_cast< int >(val1);
5401 }
5402 if (obj1) {
5403 ecode2 = SWIG_AsVal_int(obj1, &val2);
5404 if (!SWIG_IsOK(ecode2)) {
5405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5406 }
5407 arg2 = static_cast< int >(val2);
5408 }
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423 PyObject *obj;
5424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5425 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5426 return SWIG_Py_Void();
5427 }
5428
5429 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5430 return SWIG_Python_InitShadowInstance(args);
5431 }
5432
5433 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5434 PyObject *resultobj = 0;
5435 int arg1 = (int) -1 ;
5436 int arg2 = (int) -1 ;
5437 wxGridCellFloatEditor *result = 0 ;
5438 int val1 ;
5439 int ecode1 = 0 ;
5440 int val2 ;
5441 int ecode2 = 0 ;
5442 PyObject * obj0 = 0 ;
5443 PyObject * obj1 = 0 ;
5444 char * kwnames[] = {
5445 (char *) "width",(char *) "precision", NULL
5446 };
5447
5448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5449 if (obj0) {
5450 ecode1 = SWIG_AsVal_int(obj0, &val1);
5451 if (!SWIG_IsOK(ecode1)) {
5452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5453 }
5454 arg1 = static_cast< int >(val1);
5455 }
5456 if (obj1) {
5457 ecode2 = SWIG_AsVal_int(obj1, &val2);
5458 if (!SWIG_IsOK(ecode2)) {
5459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5460 }
5461 arg2 = static_cast< int >(val2);
5462 }
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *obj;
5478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5479 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5480 return SWIG_Py_Void();
5481 }
5482
5483 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 return SWIG_Python_InitShadowInstance(args);
5485 }
5486
5487 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488 PyObject *resultobj = 0;
5489 wxGridCellBoolEditor *result = 0 ;
5490
5491 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5495 wxPyEndAllowThreads(__tstate);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 PyObject *resultobj = 0;
5507 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5508 wxString result;
5509 void *argp1 = 0 ;
5510 int res1 = 0 ;
5511 PyObject *swig_obj[1] ;
5512
5513 if (!args) SWIG_fail;
5514 swig_obj[0] = args;
5515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5516 if (!SWIG_IsOK(res1)) {
5517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5518 }
5519 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5520 {
5521 PyThreadState* __tstate = wxPyBeginAllowThreads();
5522 result = (arg1)->GetValue();
5523 wxPyEndAllowThreads(__tstate);
5524 if (PyErr_Occurred()) SWIG_fail;
5525 }
5526 {
5527 #if wxUSE_UNICODE
5528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5529 #else
5530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5531 #endif
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5540 PyObject *obj;
5541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5542 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5543 return SWIG_Py_Void();
5544 }
5545
5546 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547 return SWIG_Python_InitShadowInstance(args);
5548 }
5549
5550 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj = 0;
5552 int arg1 = (int) 0 ;
5553 wxString *arg2 = (wxString *) NULL ;
5554 bool arg3 = (bool) false ;
5555 wxGridCellChoiceEditor *result = 0 ;
5556 bool val3 ;
5557 int ecode3 = 0 ;
5558 PyObject * obj0 = 0 ;
5559 PyObject * obj1 = 0 ;
5560 char * kwnames[] = {
5561 (char *) "choices",(char *) "allowOthers", NULL
5562 };
5563
5564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5565 if (obj0) {
5566 {
5567 arg1 = PyList_Size(obj0);
5568 arg2 = wxString_LIST_helper(obj0);
5569 if (arg2 == NULL) SWIG_fail;
5570 }
5571 }
5572 if (obj1) {
5573 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5574 if (!SWIG_IsOK(ecode3)) {
5575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5576 }
5577 arg3 = static_cast< bool >(val3);
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5586 {
5587 if (arg2) delete [] arg2;
5588 }
5589 return resultobj;
5590 fail:
5591 {
5592 if (arg2) delete [] arg2;
5593 }
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5599 PyObject *resultobj = 0;
5600 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5601 wxString result;
5602 void *argp1 = 0 ;
5603 int res1 = 0 ;
5604 PyObject *swig_obj[1] ;
5605
5606 if (!args) SWIG_fail;
5607 swig_obj[0] = args;
5608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5609 if (!SWIG_IsOK(res1)) {
5610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5611 }
5612 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5613 {
5614 PyThreadState* __tstate = wxPyBeginAllowThreads();
5615 result = (arg1)->GetValue();
5616 wxPyEndAllowThreads(__tstate);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 {
5620 #if wxUSE_UNICODE
5621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5622 #else
5623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5624 #endif
5625 }
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5633 PyObject *obj;
5634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5635 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5636 return SWIG_Py_Void();
5637 }
5638
5639 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5640 return SWIG_Python_InitShadowInstance(args);
5641 }
5642
5643 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5644 PyObject *resultobj = 0;
5645 wxString const &arg1_defvalue = wxPyEmptyString ;
5646 wxString *arg1 = (wxString *) &arg1_defvalue ;
5647 wxGridCellEnumEditor *result = 0 ;
5648 bool temp1 = false ;
5649 PyObject * obj0 = 0 ;
5650 char * kwnames[] = {
5651 (char *) "choices", NULL
5652 };
5653
5654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5655 if (obj0) {
5656 {
5657 arg1 = wxString_in_helper(obj0);
5658 if (arg1 == NULL) SWIG_fail;
5659 temp1 = true;
5660 }
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5665 wxPyEndAllowThreads(__tstate);
5666 if (PyErr_Occurred()) SWIG_fail;
5667 }
5668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5669 {
5670 if (temp1)
5671 delete arg1;
5672 }
5673 return resultobj;
5674 fail:
5675 {
5676 if (temp1)
5677 delete arg1;
5678 }
5679 return NULL;
5680 }
5681
5682
5683 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5684 PyObject *obj;
5685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5686 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5687 return SWIG_Py_Void();
5688 }
5689
5690 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5691 return SWIG_Python_InitShadowInstance(args);
5692 }
5693
5694 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5695 PyObject *resultobj = 0;
5696 wxGridCellAutoWrapStringEditor *result = 0 ;
5697
5698 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5699 {
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5713 PyObject *obj;
5714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5715 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5716 return SWIG_Py_Void();
5717 }
5718
5719 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5720 return SWIG_Python_InitShadowInstance(args);
5721 }
5722
5723 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj = 0;
5725 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5726 PyObject *arg2 = (PyObject *) 0 ;
5727 void *argp1 = 0 ;
5728 int res1 = 0 ;
5729 PyObject * obj0 = 0 ;
5730 PyObject * obj1 = 0 ;
5731 char * kwnames[] = {
5732 (char *) "self",(char *) "_self", NULL
5733 };
5734
5735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5737 if (!SWIG_IsOK(res1)) {
5738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5739 }
5740 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5741 arg2 = obj1;
5742 {
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 wxGridCellAttr__setOORInfo(arg1,arg2);
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 resultobj = SWIG_Py_Void();
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj = 0;
5757 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5758 wxGridCellAttr *result = 0 ;
5759 void *argp1 = 0 ;
5760 int res1 = 0 ;
5761 PyObject * obj0 = 0 ;
5762 char * kwnames[] = {
5763 (char *) "attrDefault", NULL
5764 };
5765
5766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5767 if (obj0) {
5768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5769 if (!SWIG_IsOK(res1)) {
5770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5771 }
5772 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5777 wxPyEndAllowThreads(__tstate);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 {
5781 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5782 }
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5790 PyObject *resultobj = 0;
5791 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5792 void *argp1 = 0 ;
5793 int res1 = 0 ;
5794 PyObject *swig_obj[1] ;
5795
5796 if (!args) SWIG_fail;
5797 swig_obj[0] = args;
5798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5799 if (!SWIG_IsOK(res1)) {
5800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5801 }
5802 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 delete_wxGridCellAttr(arg1);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 resultobj = SWIG_Py_Void();
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5818 PyObject *resultobj = 0;
5819 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5820 wxGridCellAttr *result = 0 ;
5821 void *argp1 = 0 ;
5822 int res1 = 0 ;
5823 PyObject *swig_obj[1] ;
5824
5825 if (!args) SWIG_fail;
5826 swig_obj[0] = args;
5827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5830 }
5831 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5850 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 void *argp2 = 0 ;
5854 int res2 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "mergefrom", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5865 }
5866 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5868 if (!SWIG_IsOK(res2)) {
5869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5870 }
5871 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 (arg1)->MergeWith(arg2);
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 resultobj = SWIG_Py_Void();
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5886 PyObject *resultobj = 0;
5887 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 PyObject *swig_obj[1] ;
5891
5892 if (!args) SWIG_fail;
5893 swig_obj[0] = args;
5894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5895 if (!SWIG_IsOK(res1)) {
5896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5897 }
5898 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5899 {
5900 PyThreadState* __tstate = wxPyBeginAllowThreads();
5901 (arg1)->IncRef();
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 resultobj = SWIG_Py_Void();
5906 return resultobj;
5907 fail:
5908 return NULL;
5909 }
5910
5911
5912 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5913 PyObject *resultobj = 0;
5914 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5915 void *argp1 = 0 ;
5916 int res1 = 0 ;
5917 PyObject *swig_obj[1] ;
5918
5919 if (!args) SWIG_fail;
5920 swig_obj[0] = args;
5921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5922 if (!SWIG_IsOK(res1)) {
5923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5924 }
5925 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5926 {
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 (arg1)->DecRef();
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 resultobj = SWIG_Py_Void();
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj = 0;
5941 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5942 wxColour *arg2 = 0 ;
5943 void *argp1 = 0 ;
5944 int res1 = 0 ;
5945 wxColour temp2 ;
5946 PyObject * obj0 = 0 ;
5947 PyObject * obj1 = 0 ;
5948 char * kwnames[] = {
5949 (char *) "self",(char *) "colText", NULL
5950 };
5951
5952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5954 if (!SWIG_IsOK(res1)) {
5955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5956 }
5957 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5958 {
5959 arg2 = &temp2;
5960 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5961 }
5962 {
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 (arg1)->SetTextColour((wxColour const &)*arg2);
5965 wxPyEndAllowThreads(__tstate);
5966 if (PyErr_Occurred()) SWIG_fail;
5967 }
5968 resultobj = SWIG_Py_Void();
5969 return resultobj;
5970 fail:
5971 return NULL;
5972 }
5973
5974
5975 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj = 0;
5977 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5978 wxColour *arg2 = 0 ;
5979 void *argp1 = 0 ;
5980 int res1 = 0 ;
5981 wxColour temp2 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 char * kwnames[] = {
5985 (char *) "self",(char *) "colBack", NULL
5986 };
5987
5988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5990 if (!SWIG_IsOK(res1)) {
5991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5992 }
5993 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5994 {
5995 arg2 = &temp2;
5996 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5997 }
5998 {
5999 PyThreadState* __tstate = wxPyBeginAllowThreads();
6000 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6001 wxPyEndAllowThreads(__tstate);
6002 if (PyErr_Occurred()) SWIG_fail;
6003 }
6004 resultobj = SWIG_Py_Void();
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj = 0;
6013 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6014 wxFont *arg2 = 0 ;
6015 void *argp1 = 0 ;
6016 int res1 = 0 ;
6017 void *argp2 = 0 ;
6018 int res2 = 0 ;
6019 PyObject * obj0 = 0 ;
6020 PyObject * obj1 = 0 ;
6021 char * kwnames[] = {
6022 (char *) "self",(char *) "font", NULL
6023 };
6024
6025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6027 if (!SWIG_IsOK(res1)) {
6028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6029 }
6030 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6032 if (!SWIG_IsOK(res2)) {
6033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6034 }
6035 if (!argp2) {
6036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6037 }
6038 arg2 = reinterpret_cast< wxFont * >(argp2);
6039 {
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 (arg1)->SetFont((wxFont const &)*arg2);
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 resultobj = SWIG_Py_Void();
6046 return resultobj;
6047 fail:
6048 return NULL;
6049 }
6050
6051
6052 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj = 0;
6054 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6055 int arg2 ;
6056 int arg3 ;
6057 void *argp1 = 0 ;
6058 int res1 = 0 ;
6059 int val2 ;
6060 int ecode2 = 0 ;
6061 int val3 ;
6062 int ecode3 = 0 ;
6063 PyObject * obj0 = 0 ;
6064 PyObject * obj1 = 0 ;
6065 PyObject * obj2 = 0 ;
6066 char * kwnames[] = {
6067 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6068 };
6069
6070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6072 if (!SWIG_IsOK(res1)) {
6073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6074 }
6075 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6076 ecode2 = SWIG_AsVal_int(obj1, &val2);
6077 if (!SWIG_IsOK(ecode2)) {
6078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6079 }
6080 arg2 = static_cast< int >(val2);
6081 ecode3 = SWIG_AsVal_int(obj2, &val3);
6082 if (!SWIG_IsOK(ecode3)) {
6083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6084 }
6085 arg3 = static_cast< int >(val3);
6086 {
6087 PyThreadState* __tstate = wxPyBeginAllowThreads();
6088 (arg1)->SetAlignment(arg2,arg3);
6089 wxPyEndAllowThreads(__tstate);
6090 if (PyErr_Occurred()) SWIG_fail;
6091 }
6092 resultobj = SWIG_Py_Void();
6093 return resultobj;
6094 fail:
6095 return NULL;
6096 }
6097
6098
6099 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6100 PyObject *resultobj = 0;
6101 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6102 int arg2 ;
6103 int arg3 ;
6104 void *argp1 = 0 ;
6105 int res1 = 0 ;
6106 int val2 ;
6107 int ecode2 = 0 ;
6108 int val3 ;
6109 int ecode3 = 0 ;
6110 PyObject * obj0 = 0 ;
6111 PyObject * obj1 = 0 ;
6112 PyObject * obj2 = 0 ;
6113 char * kwnames[] = {
6114 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6115 };
6116
6117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6119 if (!SWIG_IsOK(res1)) {
6120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6121 }
6122 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6123 ecode2 = SWIG_AsVal_int(obj1, &val2);
6124 if (!SWIG_IsOK(ecode2)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6126 }
6127 arg2 = static_cast< int >(val2);
6128 ecode3 = SWIG_AsVal_int(obj2, &val3);
6129 if (!SWIG_IsOK(ecode3)) {
6130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6131 }
6132 arg3 = static_cast< int >(val3);
6133 {
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 (arg1)->SetSize(arg2,arg3);
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 resultobj = SWIG_Py_Void();
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj = 0;
6148 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6149 bool arg2 = (bool) true ;
6150 void *argp1 = 0 ;
6151 int res1 = 0 ;
6152 bool val2 ;
6153 int ecode2 = 0 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 char * kwnames[] = {
6157 (char *) "self",(char *) "allow", NULL
6158 };
6159
6160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6162 if (!SWIG_IsOK(res1)) {
6163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6164 }
6165 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6166 if (obj1) {
6167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6168 if (!SWIG_IsOK(ecode2)) {
6169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6170 }
6171 arg2 = static_cast< bool >(val2);
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 (arg1)->SetOverflow(arg2);
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_Py_Void();
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6189 bool arg2 = (bool) true ;
6190 void *argp1 = 0 ;
6191 int res1 = 0 ;
6192 bool val2 ;
6193 int ecode2 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "self",(char *) "isReadOnly", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6202 if (!SWIG_IsOK(res1)) {
6203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6204 }
6205 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6206 if (obj1) {
6207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6208 if (!SWIG_IsOK(ecode2)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6210 }
6211 arg2 = static_cast< bool >(val2);
6212 }
6213 {
6214 PyThreadState* __tstate = wxPyBeginAllowThreads();
6215 (arg1)->SetReadOnly(arg2);
6216 wxPyEndAllowThreads(__tstate);
6217 if (PyErr_Occurred()) SWIG_fail;
6218 }
6219 resultobj = SWIG_Py_Void();
6220 return resultobj;
6221 fail:
6222 return NULL;
6223 }
6224
6225
6226 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6227 PyObject *resultobj = 0;
6228 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6229 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6230 void *argp1 = 0 ;
6231 int res1 = 0 ;
6232 void *argp2 = 0 ;
6233 int res2 = 0 ;
6234 PyObject * obj0 = 0 ;
6235 PyObject * obj1 = 0 ;
6236 char * kwnames[] = {
6237 (char *) "self",(char *) "renderer", NULL
6238 };
6239
6240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6242 if (!SWIG_IsOK(res1)) {
6243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6244 }
6245 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6247 if (!SWIG_IsOK(res2)) {
6248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6249 }
6250 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6251 {
6252 PyThreadState* __tstate = wxPyBeginAllowThreads();
6253 (arg1)->SetRenderer(arg2);
6254 wxPyEndAllowThreads(__tstate);
6255 if (PyErr_Occurred()) SWIG_fail;
6256 }
6257 resultobj = SWIG_Py_Void();
6258 return resultobj;
6259 fail:
6260 return NULL;
6261 }
6262
6263
6264 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6265 PyObject *resultobj = 0;
6266 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6267 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6268 void *argp1 = 0 ;
6269 int res1 = 0 ;
6270 void *argp2 = 0 ;
6271 int res2 = 0 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char * kwnames[] = {
6275 (char *) "self",(char *) "editor", NULL
6276 };
6277
6278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6280 if (!SWIG_IsOK(res1)) {
6281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6282 }
6283 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6285 if (!SWIG_IsOK(res2)) {
6286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6287 }
6288 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 (arg1)->SetEditor(arg2);
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_Py_Void();
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6305 wxGridCellAttr::wxAttrKind arg2 ;
6306 void *argp1 = 0 ;
6307 int res1 = 0 ;
6308 int val2 ;
6309 int ecode2 = 0 ;
6310 PyObject * obj0 = 0 ;
6311 PyObject * obj1 = 0 ;
6312 char * kwnames[] = {
6313 (char *) "self",(char *) "kind", NULL
6314 };
6315
6316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6318 if (!SWIG_IsOK(res1)) {
6319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6320 }
6321 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6322 ecode2 = SWIG_AsVal_int(obj1, &val2);
6323 if (!SWIG_IsOK(ecode2)) {
6324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6325 }
6326 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6327 {
6328 PyThreadState* __tstate = wxPyBeginAllowThreads();
6329 (arg1)->SetKind(arg2);
6330 wxPyEndAllowThreads(__tstate);
6331 if (PyErr_Occurred()) SWIG_fail;
6332 }
6333 resultobj = SWIG_Py_Void();
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6341 PyObject *resultobj = 0;
6342 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6343 bool result;
6344 void *argp1 = 0 ;
6345 int res1 = 0 ;
6346 PyObject *swig_obj[1] ;
6347
6348 if (!args) SWIG_fail;
6349 swig_obj[0] = args;
6350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6351 if (!SWIG_IsOK(res1)) {
6352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6353 }
6354 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6358 wxPyEndAllowThreads(__tstate);
6359 if (PyErr_Occurred()) SWIG_fail;
6360 }
6361 {
6362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6363 }
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6371 PyObject *resultobj = 0;
6372 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6373 bool result;
6374 void *argp1 = 0 ;
6375 int res1 = 0 ;
6376 PyObject *swig_obj[1] ;
6377
6378 if (!args) SWIG_fail;
6379 swig_obj[0] = args;
6380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6381 if (!SWIG_IsOK(res1)) {
6382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6383 }
6384 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 {
6392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6393 }
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6401 PyObject *resultobj = 0;
6402 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6403 bool result;
6404 void *argp1 = 0 ;
6405 int res1 = 0 ;
6406 PyObject *swig_obj[1] ;
6407
6408 if (!args) SWIG_fail;
6409 swig_obj[0] = args;
6410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6411 if (!SWIG_IsOK(res1)) {
6412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6413 }
6414 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6415 {
6416 PyThreadState* __tstate = wxPyBeginAllowThreads();
6417 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6418 wxPyEndAllowThreads(__tstate);
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 {
6422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6423 }
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6431 PyObject *resultobj = 0;
6432 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6433 bool result;
6434 void *argp1 = 0 ;
6435 int res1 = 0 ;
6436 PyObject *swig_obj[1] ;
6437
6438 if (!args) SWIG_fail;
6439 swig_obj[0] = args;
6440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6441 if (!SWIG_IsOK(res1)) {
6442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6443 }
6444 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 {
6452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6453 }
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6461 PyObject *resultobj = 0;
6462 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6463 bool result;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 PyObject *swig_obj[1] ;
6467
6468 if (!args) SWIG_fail;
6469 swig_obj[0] = args;
6470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6473 }
6474 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 {
6482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6483 }
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6491 PyObject *resultobj = 0;
6492 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6493 bool result;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 PyObject *swig_obj[1] ;
6497
6498 if (!args) SWIG_fail;
6499 swig_obj[0] = args;
6500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6503 }
6504 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 {
6512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6513 }
6514 return resultobj;
6515 fail:
6516 return NULL;
6517 }
6518
6519
6520 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6521 PyObject *resultobj = 0;
6522 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6523 bool result;
6524 void *argp1 = 0 ;
6525 int res1 = 0 ;
6526 PyObject *swig_obj[1] ;
6527
6528 if (!args) SWIG_fail;
6529 swig_obj[0] = args;
6530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6531 if (!SWIG_IsOK(res1)) {
6532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6533 }
6534 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6535 {
6536 PyThreadState* __tstate = wxPyBeginAllowThreads();
6537 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 {
6542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6543 }
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6551 PyObject *resultobj = 0;
6552 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6553 bool result;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 PyObject *swig_obj[1] ;
6557
6558 if (!args) SWIG_fail;
6559 swig_obj[0] = args;
6560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6561 if (!SWIG_IsOK(res1)) {
6562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6563 }
6564 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 {
6572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6573 }
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6581 PyObject *resultobj = 0;
6582 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6583 wxColour result;
6584 void *argp1 = 0 ;
6585 int res1 = 0 ;
6586 PyObject *swig_obj[1] ;
6587
6588 if (!args) SWIG_fail;
6589 swig_obj[0] = args;
6590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6591 if (!SWIG_IsOK(res1)) {
6592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6593 }
6594 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6595 {
6596 PyThreadState* __tstate = wxPyBeginAllowThreads();
6597 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6598 wxPyEndAllowThreads(__tstate);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6609 PyObject *resultobj = 0;
6610 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6611 wxColour result;
6612 void *argp1 = 0 ;
6613 int res1 = 0 ;
6614 PyObject *swig_obj[1] ;
6615
6616 if (!args) SWIG_fail;
6617 swig_obj[0] = args;
6618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6619 if (!SWIG_IsOK(res1)) {
6620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6621 }
6622 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6639 wxFont result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = ((wxGridCellAttr const *)arg1)->GetFont();
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6665 PyObject *resultobj = 0;
6666 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6667 int *arg2 = (int *) 0 ;
6668 int *arg3 = (int *) 0 ;
6669 void *argp1 = 0 ;
6670 int res1 = 0 ;
6671 int temp2 ;
6672 int res2 = SWIG_TMPOBJ ;
6673 int temp3 ;
6674 int res3 = SWIG_TMPOBJ ;
6675 PyObject *swig_obj[1] ;
6676
6677 arg2 = &temp2;
6678 arg3 = &temp3;
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6686 {
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 resultobj = SWIG_Py_Void();
6693 if (SWIG_IsTmpObj(res2)) {
6694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6695 } else {
6696 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6698 }
6699 if (SWIG_IsTmpObj(res3)) {
6700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6701 } else {
6702 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6704 }
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6712 PyObject *resultobj = 0;
6713 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6714 int *arg2 = (int *) 0 ;
6715 int *arg3 = (int *) 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 int temp2 ;
6719 int res2 = SWIG_TMPOBJ ;
6720 int temp3 ;
6721 int res3 = SWIG_TMPOBJ ;
6722 PyObject *swig_obj[1] ;
6723
6724 arg2 = &temp2;
6725 arg3 = &temp3;
6726 if (!args) SWIG_fail;
6727 swig_obj[0] = args;
6728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6731 }
6732 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_Py_Void();
6740 if (SWIG_IsTmpObj(res2)) {
6741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6742 } else {
6743 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6745 }
6746 if (SWIG_IsTmpObj(res3)) {
6747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6748 } else {
6749 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6751 }
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6759 PyObject *resultobj = 0;
6760 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6761 bool result;
6762 void *argp1 = 0 ;
6763 int res1 = 0 ;
6764 PyObject *swig_obj[1] ;
6765
6766 if (!args) SWIG_fail;
6767 swig_obj[0] = args;
6768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6769 if (!SWIG_IsOK(res1)) {
6770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6771 }
6772 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 {
6780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6781 }
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj = 0;
6790 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6791 wxGrid *arg2 = (wxGrid *) 0 ;
6792 int arg3 ;
6793 int arg4 ;
6794 wxGridCellRenderer *result = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 void *argp2 = 0 ;
6798 int res2 = 0 ;
6799 int val3 ;
6800 int ecode3 = 0 ;
6801 int val4 ;
6802 int ecode4 = 0 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 PyObject * obj2 = 0 ;
6806 PyObject * obj3 = 0 ;
6807 char * kwnames[] = {
6808 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6809 };
6810
6811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6813 if (!SWIG_IsOK(res1)) {
6814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6815 }
6816 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6818 if (!SWIG_IsOK(res2)) {
6819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6820 }
6821 arg2 = reinterpret_cast< wxGrid * >(argp2);
6822 ecode3 = SWIG_AsVal_int(obj2, &val3);
6823 if (!SWIG_IsOK(ecode3)) {
6824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6825 }
6826 arg3 = static_cast< int >(val3);
6827 ecode4 = SWIG_AsVal_int(obj3, &val4);
6828 if (!SWIG_IsOK(ecode4)) {
6829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6830 }
6831 arg4 = static_cast< int >(val4);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 {
6839 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6840 }
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6850 wxGrid *arg2 = (wxGrid *) 0 ;
6851 int arg3 ;
6852 int arg4 ;
6853 wxGridCellEditor *result = 0 ;
6854 void *argp1 = 0 ;
6855 int res1 = 0 ;
6856 void *argp2 = 0 ;
6857 int res2 = 0 ;
6858 int val3 ;
6859 int ecode3 = 0 ;
6860 int val4 ;
6861 int ecode4 = 0 ;
6862 PyObject * obj0 = 0 ;
6863 PyObject * obj1 = 0 ;
6864 PyObject * obj2 = 0 ;
6865 PyObject * obj3 = 0 ;
6866 char * kwnames[] = {
6867 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6868 };
6869
6870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6872 if (!SWIG_IsOK(res1)) {
6873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6874 }
6875 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6877 if (!SWIG_IsOK(res2)) {
6878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6879 }
6880 arg2 = reinterpret_cast< wxGrid * >(argp2);
6881 ecode3 = SWIG_AsVal_int(obj2, &val3);
6882 if (!SWIG_IsOK(ecode3)) {
6883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6884 }
6885 arg3 = static_cast< int >(val3);
6886 ecode4 = SWIG_AsVal_int(obj3, &val4);
6887 if (!SWIG_IsOK(ecode4)) {
6888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6889 }
6890 arg4 = static_cast< int >(val4);
6891 {
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 {
6898 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6899 }
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6907 PyObject *resultobj = 0;
6908 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6909 bool result;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 PyObject *swig_obj[1] ;
6913
6914 if (!args) SWIG_fail;
6915 swig_obj[0] = args;
6916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6917 if (!SWIG_IsOK(res1)) {
6918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6919 }
6920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 {
6928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6929 }
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937 PyObject *resultobj = 0;
6938 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6939 wxGridCellAttr::wxAttrKind result;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 PyObject *swig_obj[1] ;
6943
6944 if (!args) SWIG_fail;
6945 swig_obj[0] = args;
6946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6947 if (!SWIG_IsOK(res1)) {
6948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6949 }
6950 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6951 {
6952 PyThreadState* __tstate = wxPyBeginAllowThreads();
6953 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6954 wxPyEndAllowThreads(__tstate);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_From_int(static_cast< int >(result));
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6965 PyObject *resultobj = 0;
6966 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6967 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6968 void *argp1 = 0 ;
6969 int res1 = 0 ;
6970 void *argp2 = 0 ;
6971 int res2 = 0 ;
6972 PyObject * obj0 = 0 ;
6973 PyObject * obj1 = 0 ;
6974 char * kwnames[] = {
6975 (char *) "self",(char *) "defAttr", NULL
6976 };
6977
6978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6980 if (!SWIG_IsOK(res1)) {
6981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6982 }
6983 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6985 if (!SWIG_IsOK(res2)) {
6986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6987 }
6988 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6989 {
6990 PyThreadState* __tstate = wxPyBeginAllowThreads();
6991 (arg1)->SetDefAttr(arg2);
6992 wxPyEndAllowThreads(__tstate);
6993 if (PyErr_Occurred()) SWIG_fail;
6994 }
6995 resultobj = SWIG_Py_Void();
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003 PyObject *obj;
7004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7005 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7006 return SWIG_Py_Void();
7007 }
7008
7009 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 return SWIG_Python_InitShadowInstance(args);
7011 }
7012
7013 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7014 PyObject *resultobj = 0;
7015 wxGridCellAttrProvider *result = 0 ;
7016
7017 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7018 {
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 {
7025 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7026 }
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj = 0;
7035 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7036 PyObject *arg2 = (PyObject *) 0 ;
7037 void *argp1 = 0 ;
7038 int res1 = 0 ;
7039 PyObject * obj0 = 0 ;
7040 PyObject * obj1 = 0 ;
7041 char * kwnames[] = {
7042 (char *) "self",(char *) "_self", NULL
7043 };
7044
7045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7047 if (!SWIG_IsOK(res1)) {
7048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7049 }
7050 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7051 arg2 = obj1;
7052 {
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_Py_Void();
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7068 int arg2 ;
7069 int arg3 ;
7070 wxGridCellAttr::wxAttrKind arg4 ;
7071 wxGridCellAttr *result = 0 ;
7072 void *argp1 = 0 ;
7073 int res1 = 0 ;
7074 int val2 ;
7075 int ecode2 = 0 ;
7076 int val3 ;
7077 int ecode3 = 0 ;
7078 int val4 ;
7079 int ecode4 = 0 ;
7080 PyObject * obj0 = 0 ;
7081 PyObject * obj1 = 0 ;
7082 PyObject * obj2 = 0 ;
7083 PyObject * obj3 = 0 ;
7084 char * kwnames[] = {
7085 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7086 };
7087
7088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7090 if (!SWIG_IsOK(res1)) {
7091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7092 }
7093 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7094 ecode2 = SWIG_AsVal_int(obj1, &val2);
7095 if (!SWIG_IsOK(ecode2)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7097 }
7098 arg2 = static_cast< int >(val2);
7099 ecode3 = SWIG_AsVal_int(obj2, &val3);
7100 if (!SWIG_IsOK(ecode3)) {
7101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7102 }
7103 arg3 = static_cast< int >(val3);
7104 ecode4 = SWIG_AsVal_int(obj3, &val4);
7105 if (!SWIG_IsOK(ecode4)) {
7106 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7107 }
7108 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7109 {
7110 PyThreadState* __tstate = wxPyBeginAllowThreads();
7111 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = 0;
7126 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7127 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7128 int arg3 ;
7129 int arg4 ;
7130 void *argp1 = 0 ;
7131 int res1 = 0 ;
7132 void *argp2 = 0 ;
7133 int res2 = 0 ;
7134 int val3 ;
7135 int ecode3 = 0 ;
7136 int val4 ;
7137 int ecode4 = 0 ;
7138 PyObject * obj0 = 0 ;
7139 PyObject * obj1 = 0 ;
7140 PyObject * obj2 = 0 ;
7141 PyObject * obj3 = 0 ;
7142 char * kwnames[] = {
7143 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7144 };
7145
7146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7148 if (!SWIG_IsOK(res1)) {
7149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7150 }
7151 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7153 if (!SWIG_IsOK(res2)) {
7154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7155 }
7156 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7157 ecode3 = SWIG_AsVal_int(obj2, &val3);
7158 if (!SWIG_IsOK(ecode3)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7160 }
7161 arg3 = static_cast< int >(val3);
7162 ecode4 = SWIG_AsVal_int(obj3, &val4);
7163 if (!SWIG_IsOK(ecode4)) {
7164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7165 }
7166 arg4 = static_cast< int >(val4);
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 (arg1)->SetAttr(arg2,arg3,arg4);
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 resultobj = SWIG_Py_Void();
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj = 0;
7182 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7183 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7184 int arg3 ;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 void *argp2 = 0 ;
7188 int res2 = 0 ;
7189 int val3 ;
7190 int ecode3 = 0 ;
7191 PyObject * obj0 = 0 ;
7192 PyObject * obj1 = 0 ;
7193 PyObject * obj2 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "attr",(char *) "row", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7202 }
7203 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7205 if (!SWIG_IsOK(res2)) {
7206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7207 }
7208 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7209 ecode3 = SWIG_AsVal_int(obj2, &val3);
7210 if (!SWIG_IsOK(ecode3)) {
7211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7212 }
7213 arg3 = static_cast< int >(val3);
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 (arg1)->SetRowAttr(arg2,arg3);
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 resultobj = SWIG_Py_Void();
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7230 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7231 int arg3 ;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 void *argp2 = 0 ;
7235 int res2 = 0 ;
7236 int val3 ;
7237 int ecode3 = 0 ;
7238 PyObject * obj0 = 0 ;
7239 PyObject * obj1 = 0 ;
7240 PyObject * obj2 = 0 ;
7241 char * kwnames[] = {
7242 (char *) "self",(char *) "attr",(char *) "col", NULL
7243 };
7244
7245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7247 if (!SWIG_IsOK(res1)) {
7248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7249 }
7250 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7252 if (!SWIG_IsOK(res2)) {
7253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7254 }
7255 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7256 ecode3 = SWIG_AsVal_int(obj2, &val3);
7257 if (!SWIG_IsOK(ecode3)) {
7258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7259 }
7260 arg3 = static_cast< int >(val3);
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 (arg1)->SetColAttr(arg2,arg3);
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = SWIG_Py_Void();
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj = 0;
7276 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7277 size_t arg2 ;
7278 int arg3 ;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 size_t val2 ;
7282 int ecode2 = 0 ;
7283 int val3 ;
7284 int ecode3 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 PyObject * obj2 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7296 }
7297 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7298 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7299 if (!SWIG_IsOK(ecode2)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7301 }
7302 arg2 = static_cast< size_t >(val2);
7303 ecode3 = SWIG_AsVal_int(obj2, &val3);
7304 if (!SWIG_IsOK(ecode3)) {
7305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7306 }
7307 arg3 = static_cast< int >(val3);
7308 {
7309 PyThreadState* __tstate = wxPyBeginAllowThreads();
7310 (arg1)->UpdateAttrRows(arg2,arg3);
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_Py_Void();
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7324 size_t arg2 ;
7325 int arg3 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 size_t val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7343 }
7344 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7345 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7348 }
7349 arg2 = static_cast< size_t >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 (arg1)->UpdateAttrCols(arg2,arg3);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_Py_Void();
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7369 PyObject *obj;
7370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7371 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7372 return SWIG_Py_Void();
7373 }
7374
7375 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7376 return SWIG_Python_InitShadowInstance(args);
7377 }
7378
7379 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380 PyObject *resultobj = 0;
7381 wxPyGridCellAttrProvider *result = 0 ;
7382
7383 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj = 0;
7399 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7400 PyObject *arg2 = (PyObject *) 0 ;
7401 PyObject *arg3 = (PyObject *) 0 ;
7402 void *argp1 = 0 ;
7403 int res1 = 0 ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 PyObject * obj2 = 0 ;
7407 char * kwnames[] = {
7408 (char *) "self",(char *) "self",(char *) "_class", NULL
7409 };
7410
7411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7415 }
7416 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7417 arg2 = obj1;
7418 arg3 = obj2;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 (arg1)->_setCallbackInfo(arg2,arg3);
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 resultobj = SWIG_Py_Void();
7426 return resultobj;
7427 fail:
7428 return NULL;
7429 }
7430
7431
7432 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj = 0;
7434 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7435 int arg2 ;
7436 int arg3 ;
7437 wxGridCellAttr::wxAttrKind arg4 ;
7438 wxGridCellAttr *result = 0 ;
7439 void *argp1 = 0 ;
7440 int res1 = 0 ;
7441 int val2 ;
7442 int ecode2 = 0 ;
7443 int val3 ;
7444 int ecode3 = 0 ;
7445 int val4 ;
7446 int ecode4 = 0 ;
7447 PyObject * obj0 = 0 ;
7448 PyObject * obj1 = 0 ;
7449 PyObject * obj2 = 0 ;
7450 PyObject * obj3 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7459 }
7460 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7461 ecode2 = SWIG_AsVal_int(obj1, &val2);
7462 if (!SWIG_IsOK(ecode2)) {
7463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7464 }
7465 arg2 = static_cast< int >(val2);
7466 ecode3 = SWIG_AsVal_int(obj2, &val3);
7467 if (!SWIG_IsOK(ecode3)) {
7468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7469 }
7470 arg3 = static_cast< int >(val3);
7471 ecode4 = SWIG_AsVal_int(obj3, &val4);
7472 if (!SWIG_IsOK(ecode4)) {
7473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7474 }
7475 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7476 {
7477 PyThreadState* __tstate = wxPyBeginAllowThreads();
7478 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7479 wxPyEndAllowThreads(__tstate);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 {
7483 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7484 }
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj = 0;
7493 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7494 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7495 int arg3 ;
7496 int arg4 ;
7497 void *argp1 = 0 ;
7498 int res1 = 0 ;
7499 void *argp2 = 0 ;
7500 int res2 = 0 ;
7501 int val3 ;
7502 int ecode3 = 0 ;
7503 int val4 ;
7504 int ecode4 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 PyObject * obj3 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7517 }
7518 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7520 if (!SWIG_IsOK(res2)) {
7521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7522 }
7523 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 ecode4 = SWIG_AsVal_int(obj3, &val4);
7530 if (!SWIG_IsOK(ecode4)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7532 }
7533 arg4 = static_cast< int >(val4);
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 (arg1)->SetAttr(arg2,arg3,arg4);
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 resultobj = SWIG_Py_Void();
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = 0;
7549 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7550 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7551 int arg3 ;
7552 void *argp1 = 0 ;
7553 int res1 = 0 ;
7554 void *argp2 = 0 ;
7555 int res2 = 0 ;
7556 int val3 ;
7557 int ecode3 = 0 ;
7558 PyObject * obj0 = 0 ;
7559 PyObject * obj1 = 0 ;
7560 PyObject * obj2 = 0 ;
7561 char * kwnames[] = {
7562 (char *) "self",(char *) "attr",(char *) "row", NULL
7563 };
7564
7565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7569 }
7570 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7572 if (!SWIG_IsOK(res2)) {
7573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7574 }
7575 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7576 ecode3 = SWIG_AsVal_int(obj2, &val3);
7577 if (!SWIG_IsOK(ecode3)) {
7578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7579 }
7580 arg3 = static_cast< int >(val3);
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 (arg1)->SetRowAttr(arg2,arg3);
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 resultobj = SWIG_Py_Void();
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj = 0;
7596 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7597 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7598 int arg3 ;
7599 void *argp1 = 0 ;
7600 int res1 = 0 ;
7601 void *argp2 = 0 ;
7602 int res2 = 0 ;
7603 int val3 ;
7604 int ecode3 = 0 ;
7605 PyObject * obj0 = 0 ;
7606 PyObject * obj1 = 0 ;
7607 PyObject * obj2 = 0 ;
7608 char * kwnames[] = {
7609 (char *) "self",(char *) "attr",(char *) "col", NULL
7610 };
7611
7612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7616 }
7617 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7619 if (!SWIG_IsOK(res2)) {
7620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7621 }
7622 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7623 ecode3 = SWIG_AsVal_int(obj2, &val3);
7624 if (!SWIG_IsOK(ecode3)) {
7625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7626 }
7627 arg3 = static_cast< int >(val3);
7628 {
7629 PyThreadState* __tstate = wxPyBeginAllowThreads();
7630 (arg1)->SetColAttr(arg2,arg3);
7631 wxPyEndAllowThreads(__tstate);
7632 if (PyErr_Occurred()) SWIG_fail;
7633 }
7634 resultobj = SWIG_Py_Void();
7635 return resultobj;
7636 fail:
7637 return NULL;
7638 }
7639
7640
7641 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7642 PyObject *obj;
7643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7644 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7645 return SWIG_Py_Void();
7646 }
7647
7648 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7649 return SWIG_Python_InitShadowInstance(args);
7650 }
7651
7652 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 PyObject *swig_obj[1] ;
7658
7659 if (!args) SWIG_fail;
7660 swig_obj[0] = args;
7661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7664 }
7665 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7666 {
7667 PyThreadState* __tstate = wxPyBeginAllowThreads();
7668 delete arg1;
7669
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 resultobj = SWIG_Py_Void();
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj = 0;
7682 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7683 PyObject *arg2 = (PyObject *) 0 ;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 PyObject * obj0 = 0 ;
7687 PyObject * obj1 = 0 ;
7688 char * kwnames[] = {
7689 (char *) "self",(char *) "_self", NULL
7690 };
7691
7692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7694 if (!SWIG_IsOK(res1)) {
7695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7696 }
7697 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7698 arg2 = obj1;
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 wxGridTableBase__setOORInfo(arg1,arg2);
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj = 0;
7714 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7715 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 void *argp2 = 0 ;
7719 int res2 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "attrProvider", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7730 }
7731 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7733 if (!SWIG_IsOK(res2)) {
7734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7735 }
7736 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 (arg1)->SetAttrProvider(arg2);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_Py_Void();
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7751 PyObject *resultobj = 0;
7752 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7753 wxGridCellAttrProvider *result = 0 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 PyObject *swig_obj[1] ;
7757
7758 if (!args) SWIG_fail;
7759 swig_obj[0] = args;
7760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7761 if (!SWIG_IsOK(res1)) {
7762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7763 }
7764 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7765 {
7766 PyThreadState* __tstate = wxPyBeginAllowThreads();
7767 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7768 wxPyEndAllowThreads(__tstate);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7783 wxGrid *arg2 = (wxGrid *) 0 ;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 void *argp2 = 0 ;
7787 int res2 = 0 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "grid", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7798 }
7799 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7801 if (!SWIG_IsOK(res2)) {
7802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7803 }
7804 arg2 = reinterpret_cast< wxGrid * >(argp2);
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 (arg1)->SetView(arg2);
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_Py_Void();
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7819 PyObject *resultobj = 0;
7820 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7821 wxGrid *result = 0 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 PyObject *swig_obj[1] ;
7825
7826 if (!args) SWIG_fail;
7827 swig_obj[0] = args;
7828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7829 if (!SWIG_IsOK(res1)) {
7830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7831 }
7832 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7833 {
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 {
7840 resultobj = wxPyMake_wxObject(result, (bool)0);
7841 }
7842 return resultobj;
7843 fail:
7844 return NULL;
7845 }
7846
7847
7848 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7849 PyObject *resultobj = 0;
7850 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7851 int result;
7852 void *argp1 = 0 ;
7853 int res1 = 0 ;
7854 PyObject *swig_obj[1] ;
7855
7856 if (!args) SWIG_fail;
7857 swig_obj[0] = args;
7858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7861 }
7862 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 result = (int)(arg1)->GetNumberRows();
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 resultobj = SWIG_From_int(static_cast< int >(result));
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7877 PyObject *resultobj = 0;
7878 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7879 int result;
7880 void *argp1 = 0 ;
7881 int res1 = 0 ;
7882 PyObject *swig_obj[1] ;
7883
7884 if (!args) SWIG_fail;
7885 swig_obj[0] = args;
7886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7889 }
7890 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (int)(arg1)->GetNumberCols();
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = SWIG_From_int(static_cast< int >(result));
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj = 0;
7906 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7907 int arg2 ;
7908 int arg3 ;
7909 bool result;
7910 void *argp1 = 0 ;
7911 int res1 = 0 ;
7912 int val2 ;
7913 int ecode2 = 0 ;
7914 int val3 ;
7915 int ecode3 = 0 ;
7916 PyObject * obj0 = 0 ;
7917 PyObject * obj1 = 0 ;
7918 PyObject * obj2 = 0 ;
7919 char * kwnames[] = {
7920 (char *) "self",(char *) "row",(char *) "col", NULL
7921 };
7922
7923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7925 if (!SWIG_IsOK(res1)) {
7926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7927 }
7928 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7929 ecode2 = SWIG_AsVal_int(obj1, &val2);
7930 if (!SWIG_IsOK(ecode2)) {
7931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7932 }
7933 arg2 = static_cast< int >(val2);
7934 ecode3 = SWIG_AsVal_int(obj2, &val3);
7935 if (!SWIG_IsOK(ecode3)) {
7936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7937 }
7938 arg3 = static_cast< int >(val3);
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 {
7946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7947 }
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj = 0;
7956 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7957 int arg2 ;
7958 int arg3 ;
7959 wxString result;
7960 void *argp1 = 0 ;
7961 int res1 = 0 ;
7962 int val2 ;
7963 int ecode2 = 0 ;
7964 int val3 ;
7965 int ecode3 = 0 ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 PyObject * obj2 = 0 ;
7969 char * kwnames[] = {
7970 (char *) "self",(char *) "row",(char *) "col", NULL
7971 };
7972
7973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7975 if (!SWIG_IsOK(res1)) {
7976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7977 }
7978 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7979 ecode2 = SWIG_AsVal_int(obj1, &val2);
7980 if (!SWIG_IsOK(ecode2)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7982 }
7983 arg2 = static_cast< int >(val2);
7984 ecode3 = SWIG_AsVal_int(obj2, &val3);
7985 if (!SWIG_IsOK(ecode3)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7987 }
7988 arg3 = static_cast< int >(val3);
7989 {
7990 PyThreadState* __tstate = wxPyBeginAllowThreads();
7991 result = (arg1)->GetValue(arg2,arg3);
7992 wxPyEndAllowThreads(__tstate);
7993 if (PyErr_Occurred()) SWIG_fail;
7994 }
7995 {
7996 #if wxUSE_UNICODE
7997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7998 #else
7999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8000 #endif
8001 }
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8009 PyObject *resultobj = 0;
8010 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8011 int arg2 ;
8012 int arg3 ;
8013 wxString *arg4 = 0 ;
8014 void *argp1 = 0 ;
8015 int res1 = 0 ;
8016 int val2 ;
8017 int ecode2 = 0 ;
8018 int val3 ;
8019 int ecode3 = 0 ;
8020 bool temp4 = false ;
8021 PyObject * obj0 = 0 ;
8022 PyObject * obj1 = 0 ;
8023 PyObject * obj2 = 0 ;
8024 PyObject * obj3 = 0 ;
8025 char * kwnames[] = {
8026 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8027 };
8028
8029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8031 if (!SWIG_IsOK(res1)) {
8032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8033 }
8034 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8035 ecode2 = SWIG_AsVal_int(obj1, &val2);
8036 if (!SWIG_IsOK(ecode2)) {
8037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8038 }
8039 arg2 = static_cast< int >(val2);
8040 ecode3 = SWIG_AsVal_int(obj2, &val3);
8041 if (!SWIG_IsOK(ecode3)) {
8042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8043 }
8044 arg3 = static_cast< int >(val3);
8045 {
8046 arg4 = wxString_in_helper(obj3);
8047 if (arg4 == NULL) SWIG_fail;
8048 temp4 = true;
8049 }
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 {
8058 if (temp4)
8059 delete arg4;
8060 }
8061 return resultobj;
8062 fail:
8063 {
8064 if (temp4)
8065 delete arg4;
8066 }
8067 return NULL;
8068 }
8069
8070
8071 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj = 0;
8073 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8074 int arg2 ;
8075 int arg3 ;
8076 wxString result;
8077 void *argp1 = 0 ;
8078 int res1 = 0 ;
8079 int val2 ;
8080 int ecode2 = 0 ;
8081 int val3 ;
8082 int ecode3 = 0 ;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 PyObject * obj2 = 0 ;
8086 char * kwnames[] = {
8087 (char *) "self",(char *) "row",(char *) "col", NULL
8088 };
8089
8090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8094 }
8095 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8096 ecode2 = SWIG_AsVal_int(obj1, &val2);
8097 if (!SWIG_IsOK(ecode2)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8099 }
8100 arg2 = static_cast< int >(val2);
8101 ecode3 = SWIG_AsVal_int(obj2, &val3);
8102 if (!SWIG_IsOK(ecode3)) {
8103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8104 }
8105 arg3 = static_cast< int >(val3);
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (arg1)->GetTypeName(arg2,arg3);
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 {
8113 #if wxUSE_UNICODE
8114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8115 #else
8116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8117 #endif
8118 }
8119 return resultobj;
8120 fail:
8121 return NULL;
8122 }
8123
8124
8125 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(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_CanGetValueAs",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_CanGetValueAs" "', 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_CanGetValueAs" "', 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_CanGetValueAs" "', 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)->CanGetValueAs(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_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj = 0;
8193 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8194 int arg2 ;
8195 int arg3 ;
8196 wxString *arg4 = 0 ;
8197 bool result;
8198 void *argp1 = 0 ;
8199 int res1 = 0 ;
8200 int val2 ;
8201 int ecode2 = 0 ;
8202 int val3 ;
8203 int ecode3 = 0 ;
8204 bool temp4 = false ;
8205 PyObject * obj0 = 0 ;
8206 PyObject * obj1 = 0 ;
8207 PyObject * obj2 = 0 ;
8208 PyObject * obj3 = 0 ;
8209 char * kwnames[] = {
8210 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8211 };
8212
8213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8215 if (!SWIG_IsOK(res1)) {
8216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8217 }
8218 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8219 ecode2 = SWIG_AsVal_int(obj1, &val2);
8220 if (!SWIG_IsOK(ecode2)) {
8221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8222 }
8223 arg2 = static_cast< int >(val2);
8224 ecode3 = SWIG_AsVal_int(obj2, &val3);
8225 if (!SWIG_IsOK(ecode3)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8227 }
8228 arg3 = static_cast< int >(val3);
8229 {
8230 arg4 = wxString_in_helper(obj3);
8231 if (arg4 == NULL) SWIG_fail;
8232 temp4 = true;
8233 }
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 {
8241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8242 }
8243 {
8244 if (temp4)
8245 delete arg4;
8246 }
8247 return resultobj;
8248 fail:
8249 {
8250 if (temp4)
8251 delete arg4;
8252 }
8253 return NULL;
8254 }
8255
8256
8257 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj = 0;
8259 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8260 int arg2 ;
8261 int arg3 ;
8262 long result;
8263 void *argp1 = 0 ;
8264 int res1 = 0 ;
8265 int val2 ;
8266 int ecode2 = 0 ;
8267 int val3 ;
8268 int ecode3 = 0 ;
8269 PyObject * obj0 = 0 ;
8270 PyObject * obj1 = 0 ;
8271 PyObject * obj2 = 0 ;
8272 char * kwnames[] = {
8273 (char *) "self",(char *) "row",(char *) "col", NULL
8274 };
8275
8276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8280 }
8281 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8282 ecode2 = SWIG_AsVal_int(obj1, &val2);
8283 if (!SWIG_IsOK(ecode2)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8285 }
8286 arg2 = static_cast< int >(val2);
8287 ecode3 = SWIG_AsVal_int(obj2, &val3);
8288 if (!SWIG_IsOK(ecode3)) {
8289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8290 }
8291 arg3 = static_cast< int >(val3);
8292 {
8293 PyThreadState* __tstate = wxPyBeginAllowThreads();
8294 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 resultobj = SWIG_From_long(static_cast< long >(result));
8299 return resultobj;
8300 fail:
8301 return NULL;
8302 }
8303
8304
8305 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj = 0;
8307 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8308 int arg2 ;
8309 int arg3 ;
8310 double result;
8311 void *argp1 = 0 ;
8312 int res1 = 0 ;
8313 int val2 ;
8314 int ecode2 = 0 ;
8315 int val3 ;
8316 int ecode3 = 0 ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 PyObject * obj2 = 0 ;
8320 char * kwnames[] = {
8321 (char *) "self",(char *) "row",(char *) "col", NULL
8322 };
8323
8324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8328 }
8329 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8330 ecode2 = SWIG_AsVal_int(obj1, &val2);
8331 if (!SWIG_IsOK(ecode2)) {
8332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8333 }
8334 arg2 = static_cast< int >(val2);
8335 ecode3 = SWIG_AsVal_int(obj2, &val3);
8336 if (!SWIG_IsOK(ecode3)) {
8337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8338 }
8339 arg3 = static_cast< int >(val3);
8340 {
8341 PyThreadState* __tstate = wxPyBeginAllowThreads();
8342 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8343 wxPyEndAllowThreads(__tstate);
8344 if (PyErr_Occurred()) SWIG_fail;
8345 }
8346 resultobj = SWIG_From_double(static_cast< double >(result));
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj = 0;
8355 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8356 int arg2 ;
8357 int arg3 ;
8358 bool result;
8359 void *argp1 = 0 ;
8360 int res1 = 0 ;
8361 int val2 ;
8362 int ecode2 = 0 ;
8363 int val3 ;
8364 int ecode3 = 0 ;
8365 PyObject * obj0 = 0 ;
8366 PyObject * obj1 = 0 ;
8367 PyObject * obj2 = 0 ;
8368 char * kwnames[] = {
8369 (char *) "self",(char *) "row",(char *) "col", NULL
8370 };
8371
8372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8374 if (!SWIG_IsOK(res1)) {
8375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8376 }
8377 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8378 ecode2 = SWIG_AsVal_int(obj1, &val2);
8379 if (!SWIG_IsOK(ecode2)) {
8380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8381 }
8382 arg2 = static_cast< int >(val2);
8383 ecode3 = SWIG_AsVal_int(obj2, &val3);
8384 if (!SWIG_IsOK(ecode3)) {
8385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8386 }
8387 arg3 = static_cast< int >(val3);
8388 {
8389 PyThreadState* __tstate = wxPyBeginAllowThreads();
8390 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8396 }
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj = 0;
8405 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8406 int arg2 ;
8407 int arg3 ;
8408 long arg4 ;
8409 void *argp1 = 0 ;
8410 int res1 = 0 ;
8411 int val2 ;
8412 int ecode2 = 0 ;
8413 int val3 ;
8414 int ecode3 = 0 ;
8415 long val4 ;
8416 int ecode4 = 0 ;
8417 PyObject * obj0 = 0 ;
8418 PyObject * obj1 = 0 ;
8419 PyObject * obj2 = 0 ;
8420 PyObject * obj3 = 0 ;
8421 char * kwnames[] = {
8422 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8423 };
8424
8425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8429 }
8430 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8431 ecode2 = SWIG_AsVal_int(obj1, &val2);
8432 if (!SWIG_IsOK(ecode2)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8434 }
8435 arg2 = static_cast< int >(val2);
8436 ecode3 = SWIG_AsVal_int(obj2, &val3);
8437 if (!SWIG_IsOK(ecode3)) {
8438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8439 }
8440 arg3 = static_cast< int >(val3);
8441 ecode4 = SWIG_AsVal_long(obj3, &val4);
8442 if (!SWIG_IsOK(ecode4)) {
8443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8444 }
8445 arg4 = static_cast< long >(val4);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_Py_Void();
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8460 PyObject *resultobj = 0;
8461 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8462 int arg2 ;
8463 int arg3 ;
8464 double arg4 ;
8465 void *argp1 = 0 ;
8466 int res1 = 0 ;
8467 int val2 ;
8468 int ecode2 = 0 ;
8469 int val3 ;
8470 int ecode3 = 0 ;
8471 double val4 ;
8472 int ecode4 = 0 ;
8473 PyObject * obj0 = 0 ;
8474 PyObject * obj1 = 0 ;
8475 PyObject * obj2 = 0 ;
8476 PyObject * obj3 = 0 ;
8477 char * kwnames[] = {
8478 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8479 };
8480
8481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8485 }
8486 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8487 ecode2 = SWIG_AsVal_int(obj1, &val2);
8488 if (!SWIG_IsOK(ecode2)) {
8489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8490 }
8491 arg2 = static_cast< int >(val2);
8492 ecode3 = SWIG_AsVal_int(obj2, &val3);
8493 if (!SWIG_IsOK(ecode3)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8495 }
8496 arg3 = static_cast< int >(val3);
8497 ecode4 = SWIG_AsVal_double(obj3, &val4);
8498 if (!SWIG_IsOK(ecode4)) {
8499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8500 }
8501 arg4 = static_cast< double >(val4);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_Py_Void();
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj = 0;
8517 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8518 int arg2 ;
8519 int arg3 ;
8520 bool arg4 ;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 int val2 ;
8524 int ecode2 = 0 ;
8525 int val3 ;
8526 int ecode3 = 0 ;
8527 bool val4 ;
8528 int ecode4 = 0 ;
8529 PyObject * obj0 = 0 ;
8530 PyObject * obj1 = 0 ;
8531 PyObject * obj2 = 0 ;
8532 PyObject * obj3 = 0 ;
8533 char * kwnames[] = {
8534 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8535 };
8536
8537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8539 if (!SWIG_IsOK(res1)) {
8540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8541 }
8542 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8543 ecode2 = SWIG_AsVal_int(obj1, &val2);
8544 if (!SWIG_IsOK(ecode2)) {
8545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8546 }
8547 arg2 = static_cast< int >(val2);
8548 ecode3 = SWIG_AsVal_int(obj2, &val3);
8549 if (!SWIG_IsOK(ecode3)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8551 }
8552 arg3 = static_cast< int >(val3);
8553 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8554 if (!SWIG_IsOK(ecode4)) {
8555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8556 }
8557 arg4 = static_cast< bool >(val4);
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 resultobj = SWIG_Py_Void();
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8572 PyObject *resultobj = 0;
8573 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8574 void *argp1 = 0 ;
8575 int res1 = 0 ;
8576 PyObject *swig_obj[1] ;
8577
8578 if (!args) SWIG_fail;
8579 swig_obj[0] = args;
8580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8581 if (!SWIG_IsOK(res1)) {
8582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8583 }
8584 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 (arg1)->Clear();
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_Py_Void();
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8601 size_t arg2 = (size_t) 0 ;
8602 size_t arg3 = (size_t) 1 ;
8603 bool result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 size_t val2 ;
8607 int ecode2 = 0 ;
8608 size_t val3 ;
8609 int ecode3 = 0 ;
8610 PyObject * obj0 = 0 ;
8611 PyObject * obj1 = 0 ;
8612 PyObject * obj2 = 0 ;
8613 char * kwnames[] = {
8614 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8615 };
8616
8617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8619 if (!SWIG_IsOK(res1)) {
8620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8621 }
8622 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8623 if (obj1) {
8624 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8625 if (!SWIG_IsOK(ecode2)) {
8626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8627 }
8628 arg2 = static_cast< size_t >(val2);
8629 }
8630 if (obj2) {
8631 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8632 if (!SWIG_IsOK(ecode3)) {
8633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8634 }
8635 arg3 = static_cast< size_t >(val3);
8636 }
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 result = (bool)(arg1)->InsertRows(arg2,arg3);
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 {
8644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8645 }
8646 return resultobj;
8647 fail:
8648 return NULL;
8649 }
8650
8651
8652 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8653 PyObject *resultobj = 0;
8654 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8655 size_t arg2 = (size_t) 1 ;
8656 bool result;
8657 void *argp1 = 0 ;
8658 int res1 = 0 ;
8659 size_t val2 ;
8660 int ecode2 = 0 ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char * kwnames[] = {
8664 (char *) "self",(char *) "numRows", NULL
8665 };
8666
8667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8671 }
8672 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8673 if (obj1) {
8674 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8675 if (!SWIG_IsOK(ecode2)) {
8676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8677 }
8678 arg2 = static_cast< size_t >(val2);
8679 }
8680 {
8681 PyThreadState* __tstate = wxPyBeginAllowThreads();
8682 result = (bool)(arg1)->AppendRows(arg2);
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 {
8687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8688 }
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8696 PyObject *resultobj = 0;
8697 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8698 size_t arg2 = (size_t) 0 ;
8699 size_t arg3 = (size_t) 1 ;
8700 bool result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 size_t val2 ;
8704 int ecode2 = 0 ;
8705 size_t val3 ;
8706 int ecode3 = 0 ;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 PyObject * obj2 = 0 ;
8710 char * kwnames[] = {
8711 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8712 };
8713
8714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8716 if (!SWIG_IsOK(res1)) {
8717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8718 }
8719 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8720 if (obj1) {
8721 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8722 if (!SWIG_IsOK(ecode2)) {
8723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8724 }
8725 arg2 = static_cast< size_t >(val2);
8726 }
8727 if (obj2) {
8728 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8729 if (!SWIG_IsOK(ecode3)) {
8730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8731 }
8732 arg3 = static_cast< size_t >(val3);
8733 }
8734 {
8735 PyThreadState* __tstate = wxPyBeginAllowThreads();
8736 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8737 wxPyEndAllowThreads(__tstate);
8738 if (PyErr_Occurred()) SWIG_fail;
8739 }
8740 {
8741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8742 }
8743 return resultobj;
8744 fail:
8745 return NULL;
8746 }
8747
8748
8749 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj = 0;
8751 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8752 size_t arg2 = (size_t) 0 ;
8753 size_t arg3 = (size_t) 1 ;
8754 bool result;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 size_t val2 ;
8758 int ecode2 = 0 ;
8759 size_t val3 ;
8760 int ecode3 = 0 ;
8761 PyObject * obj0 = 0 ;
8762 PyObject * obj1 = 0 ;
8763 PyObject * obj2 = 0 ;
8764 char * kwnames[] = {
8765 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8766 };
8767
8768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8770 if (!SWIG_IsOK(res1)) {
8771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8772 }
8773 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8774 if (obj1) {
8775 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8776 if (!SWIG_IsOK(ecode2)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8778 }
8779 arg2 = static_cast< size_t >(val2);
8780 }
8781 if (obj2) {
8782 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8783 if (!SWIG_IsOK(ecode3)) {
8784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8785 }
8786 arg3 = static_cast< size_t >(val3);
8787 }
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (bool)(arg1)->InsertCols(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 {
8795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8796 }
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj = 0;
8805 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8806 size_t arg2 = (size_t) 1 ;
8807 bool result;
8808 void *argp1 = 0 ;
8809 int res1 = 0 ;
8810 size_t val2 ;
8811 int ecode2 = 0 ;
8812 PyObject * obj0 = 0 ;
8813 PyObject * obj1 = 0 ;
8814 char * kwnames[] = {
8815 (char *) "self",(char *) "numCols", NULL
8816 };
8817
8818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8820 if (!SWIG_IsOK(res1)) {
8821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8822 }
8823 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8824 if (obj1) {
8825 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8826 if (!SWIG_IsOK(ecode2)) {
8827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8828 }
8829 arg2 = static_cast< size_t >(val2);
8830 }
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 result = (bool)(arg1)->AppendCols(arg2);
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 {
8838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8839 }
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8847 PyObject *resultobj = 0;
8848 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8849 size_t arg2 = (size_t) 0 ;
8850 size_t arg3 = (size_t) 1 ;
8851 bool result;
8852 void *argp1 = 0 ;
8853 int res1 = 0 ;
8854 size_t val2 ;
8855 int ecode2 = 0 ;
8856 size_t val3 ;
8857 int ecode3 = 0 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 PyObject * obj2 = 0 ;
8861 char * kwnames[] = {
8862 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8863 };
8864
8865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8867 if (!SWIG_IsOK(res1)) {
8868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8869 }
8870 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8871 if (obj1) {
8872 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8873 if (!SWIG_IsOK(ecode2)) {
8874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8875 }
8876 arg2 = static_cast< size_t >(val2);
8877 }
8878 if (obj2) {
8879 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8880 if (!SWIG_IsOK(ecode3)) {
8881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8882 }
8883 arg3 = static_cast< size_t >(val3);
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 {
8892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8893 }
8894 return resultobj;
8895 fail:
8896 return NULL;
8897 }
8898
8899
8900 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj = 0;
8902 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8903 int arg2 ;
8904 wxString result;
8905 void *argp1 = 0 ;
8906 int res1 = 0 ;
8907 int val2 ;
8908 int ecode2 = 0 ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 char * kwnames[] = {
8912 (char *) "self",(char *) "row", NULL
8913 };
8914
8915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8917 if (!SWIG_IsOK(res1)) {
8918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8919 }
8920 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8921 ecode2 = SWIG_AsVal_int(obj1, &val2);
8922 if (!SWIG_IsOK(ecode2)) {
8923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8924 }
8925 arg2 = static_cast< int >(val2);
8926 {
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 result = (arg1)->GetRowLabelValue(arg2);
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 {
8933 #if wxUSE_UNICODE
8934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8935 #else
8936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8937 #endif
8938 }
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8948 int arg2 ;
8949 wxString result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 int val2 ;
8953 int ecode2 = 0 ;
8954 PyObject * obj0 = 0 ;
8955 PyObject * obj1 = 0 ;
8956 char * kwnames[] = {
8957 (char *) "self",(char *) "col", NULL
8958 };
8959
8960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8964 }
8965 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8966 ecode2 = SWIG_AsVal_int(obj1, &val2);
8967 if (!SWIG_IsOK(ecode2)) {
8968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8969 }
8970 arg2 = static_cast< int >(val2);
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (arg1)->GetColLabelValue(arg2);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 {
8978 #if wxUSE_UNICODE
8979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8980 #else
8981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8982 #endif
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj = 0;
8992 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8993 int arg2 ;
8994 wxString *arg3 = 0 ;
8995 void *argp1 = 0 ;
8996 int res1 = 0 ;
8997 int val2 ;
8998 int ecode2 = 0 ;
8999 bool temp3 = false ;
9000 PyObject * obj0 = 0 ;
9001 PyObject * obj1 = 0 ;
9002 PyObject * obj2 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "self",(char *) "row",(char *) "value", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9009 if (!SWIG_IsOK(res1)) {
9010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9011 }
9012 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9013 ecode2 = SWIG_AsVal_int(obj1, &val2);
9014 if (!SWIG_IsOK(ecode2)) {
9015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9016 }
9017 arg2 = static_cast< int >(val2);
9018 {
9019 arg3 = wxString_in_helper(obj2);
9020 if (arg3 == NULL) SWIG_fail;
9021 temp3 = true;
9022 }
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 resultobj = SWIG_Py_Void();
9030 {
9031 if (temp3)
9032 delete arg3;
9033 }
9034 return resultobj;
9035 fail:
9036 {
9037 if (temp3)
9038 delete arg3;
9039 }
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj = 0;
9046 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9047 int arg2 ;
9048 wxString *arg3 = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 int val2 ;
9052 int ecode2 = 0 ;
9053 bool temp3 = false ;
9054 PyObject * obj0 = 0 ;
9055 PyObject * obj1 = 0 ;
9056 PyObject * obj2 = 0 ;
9057 char * kwnames[] = {
9058 (char *) "self",(char *) "col",(char *) "value", NULL
9059 };
9060
9061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9063 if (!SWIG_IsOK(res1)) {
9064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9065 }
9066 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9067 ecode2 = SWIG_AsVal_int(obj1, &val2);
9068 if (!SWIG_IsOK(ecode2)) {
9069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9070 }
9071 arg2 = static_cast< int >(val2);
9072 {
9073 arg3 = wxString_in_helper(obj2);
9074 if (arg3 == NULL) SWIG_fail;
9075 temp3 = true;
9076 }
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = SWIG_Py_Void();
9084 {
9085 if (temp3)
9086 delete arg3;
9087 }
9088 return resultobj;
9089 fail:
9090 {
9091 if (temp3)
9092 delete arg3;
9093 }
9094 return NULL;
9095 }
9096
9097
9098 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099 PyObject *resultobj = 0;
9100 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9101 bool result;
9102 void *argp1 = 0 ;
9103 int res1 = 0 ;
9104 PyObject *swig_obj[1] ;
9105
9106 if (!args) SWIG_fail;
9107 swig_obj[0] = args;
9108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9109 if (!SWIG_IsOK(res1)) {
9110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9111 }
9112 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 result = (bool)(arg1)->CanHaveAttributes();
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 {
9120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9121 }
9122 return resultobj;
9123 fail:
9124 return NULL;
9125 }
9126
9127
9128 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj = 0;
9130 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9131 int arg2 ;
9132 int arg3 ;
9133 wxGridCellAttr::wxAttrKind arg4 ;
9134 wxGridCellAttr *result = 0 ;
9135 void *argp1 = 0 ;
9136 int res1 = 0 ;
9137 int val2 ;
9138 int ecode2 = 0 ;
9139 int val3 ;
9140 int ecode3 = 0 ;
9141 int val4 ;
9142 int ecode4 = 0 ;
9143 PyObject * obj0 = 0 ;
9144 PyObject * obj1 = 0 ;
9145 PyObject * obj2 = 0 ;
9146 PyObject * obj3 = 0 ;
9147 char * kwnames[] = {
9148 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9149 };
9150
9151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9153 if (!SWIG_IsOK(res1)) {
9154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9155 }
9156 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9157 ecode2 = SWIG_AsVal_int(obj1, &val2);
9158 if (!SWIG_IsOK(ecode2)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9160 }
9161 arg2 = static_cast< int >(val2);
9162 ecode3 = SWIG_AsVal_int(obj2, &val3);
9163 if (!SWIG_IsOK(ecode3)) {
9164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9165 }
9166 arg3 = static_cast< int >(val3);
9167 ecode4 = SWIG_AsVal_int(obj3, &val4);
9168 if (!SWIG_IsOK(ecode4)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9170 }
9171 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 {
9179 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9180 }
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj = 0;
9189 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9190 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9191 int arg3 ;
9192 int arg4 ;
9193 void *argp1 = 0 ;
9194 int res1 = 0 ;
9195 void *argp2 = 0 ;
9196 int res2 = 0 ;
9197 int val3 ;
9198 int ecode3 = 0 ;
9199 int val4 ;
9200 int ecode4 = 0 ;
9201 PyObject * obj0 = 0 ;
9202 PyObject * obj1 = 0 ;
9203 PyObject * obj2 = 0 ;
9204 PyObject * obj3 = 0 ;
9205 char * kwnames[] = {
9206 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9207 };
9208
9209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9211 if (!SWIG_IsOK(res1)) {
9212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9213 }
9214 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9216 if (!SWIG_IsOK(res2)) {
9217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9218 }
9219 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9220 ecode3 = SWIG_AsVal_int(obj2, &val3);
9221 if (!SWIG_IsOK(ecode3)) {
9222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9223 }
9224 arg3 = static_cast< int >(val3);
9225 ecode4 = SWIG_AsVal_int(obj3, &val4);
9226 if (!SWIG_IsOK(ecode4)) {
9227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9228 }
9229 arg4 = static_cast< int >(val4);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 (arg1)->SetAttr(arg2,arg3,arg4);
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_Py_Void();
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj = 0;
9245 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9246 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9247 int arg3 ;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 void *argp2 = 0 ;
9251 int res2 = 0 ;
9252 int val3 ;
9253 int ecode3 = 0 ;
9254 PyObject * obj0 = 0 ;
9255 PyObject * obj1 = 0 ;
9256 PyObject * obj2 = 0 ;
9257 char * kwnames[] = {
9258 (char *) "self",(char *) "attr",(char *) "row", NULL
9259 };
9260
9261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9263 if (!SWIG_IsOK(res1)) {
9264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9265 }
9266 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9268 if (!SWIG_IsOK(res2)) {
9269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9270 }
9271 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9272 ecode3 = SWIG_AsVal_int(obj2, &val3);
9273 if (!SWIG_IsOK(ecode3)) {
9274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9275 }
9276 arg3 = static_cast< int >(val3);
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 (arg1)->SetRowAttr(arg2,arg3);
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_Py_Void();
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9291 PyObject *resultobj = 0;
9292 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9293 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9294 int arg3 ;
9295 void *argp1 = 0 ;
9296 int res1 = 0 ;
9297 void *argp2 = 0 ;
9298 int res2 = 0 ;
9299 int val3 ;
9300 int ecode3 = 0 ;
9301 PyObject * obj0 = 0 ;
9302 PyObject * obj1 = 0 ;
9303 PyObject * obj2 = 0 ;
9304 char * kwnames[] = {
9305 (char *) "self",(char *) "attr",(char *) "col", NULL
9306 };
9307
9308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9312 }
9313 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9315 if (!SWIG_IsOK(res2)) {
9316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9317 }
9318 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9319 ecode3 = SWIG_AsVal_int(obj2, &val3);
9320 if (!SWIG_IsOK(ecode3)) {
9321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9322 }
9323 arg3 = static_cast< int >(val3);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 (arg1)->SetColAttr(arg2,arg3);
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_Py_Void();
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338 PyObject *obj;
9339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9340 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9341 return SWIG_Py_Void();
9342 }
9343
9344 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxPyGridTableBase *result = 0 ;
9347
9348 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9349 {
9350 PyThreadState* __tstate = wxPyBeginAllowThreads();
9351 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9356 return resultobj;
9357 fail:
9358 return NULL;
9359 }
9360
9361
9362 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj = 0;
9364 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9365 PyObject *arg2 = (PyObject *) 0 ;
9366 PyObject *arg3 = (PyObject *) 0 ;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 PyObject * obj0 = 0 ;
9370 PyObject * obj1 = 0 ;
9371 PyObject * obj2 = 0 ;
9372 char * kwnames[] = {
9373 (char *) "self",(char *) "self",(char *) "_class", NULL
9374 };
9375
9376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9378 if (!SWIG_IsOK(res1)) {
9379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9380 }
9381 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9382 arg2 = obj1;
9383 arg3 = obj2;
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 (arg1)->_setCallbackInfo(arg2,arg3);
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_Py_Void();
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9398 PyObject *resultobj = 0;
9399 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9400 void *argp1 = 0 ;
9401 int res1 = 0 ;
9402 PyObject *swig_obj[1] ;
9403
9404 if (!args) SWIG_fail;
9405 swig_obj[0] = args;
9406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9407 if (!SWIG_IsOK(res1)) {
9408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9409 }
9410 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 wxPyGridTableBase_Destroy(arg1);
9414 wxPyEndAllowThreads(__tstate);
9415 if (PyErr_Occurred()) SWIG_fail;
9416 }
9417 resultobj = SWIG_Py_Void();
9418 return resultobj;
9419 fail:
9420 return NULL;
9421 }
9422
9423
9424 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9425 PyObject *obj;
9426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9427 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9428 return SWIG_Py_Void();
9429 }
9430
9431 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9432 return SWIG_Python_InitShadowInstance(args);
9433 }
9434
9435 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj = 0;
9437 int arg1 = (int) 0 ;
9438 int arg2 = (int) 0 ;
9439 wxGridStringTable *result = 0 ;
9440 int val1 ;
9441 int ecode1 = 0 ;
9442 int val2 ;
9443 int ecode2 = 0 ;
9444 PyObject * obj0 = 0 ;
9445 PyObject * obj1 = 0 ;
9446 char * kwnames[] = {
9447 (char *) "numRows",(char *) "numCols", NULL
9448 };
9449
9450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9451 if (obj0) {
9452 ecode1 = SWIG_AsVal_int(obj0, &val1);
9453 if (!SWIG_IsOK(ecode1)) {
9454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9455 }
9456 arg1 = static_cast< int >(val1);
9457 }
9458 if (obj1) {
9459 ecode2 = SWIG_AsVal_int(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9462 }
9463 arg2 = static_cast< int >(val2);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9479 PyObject *obj;
9480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9481 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9482 return SWIG_Py_Void();
9483 }
9484
9485 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9486 return SWIG_Python_InitShadowInstance(args);
9487 }
9488
9489 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9492 int arg2 ;
9493 int arg3 = (int) -1 ;
9494 int arg4 = (int) -1 ;
9495 wxGridTableMessage *result = 0 ;
9496 void *argp1 = 0 ;
9497 int res1 = 0 ;
9498 int val2 ;
9499 int ecode2 = 0 ;
9500 int val3 ;
9501 int ecode3 = 0 ;
9502 int val4 ;
9503 int ecode4 = 0 ;
9504 PyObject * obj0 = 0 ;
9505 PyObject * obj1 = 0 ;
9506 PyObject * obj2 = 0 ;
9507 PyObject * obj3 = 0 ;
9508 char * kwnames[] = {
9509 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9510 };
9511
9512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9514 if (!SWIG_IsOK(res1)) {
9515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9516 }
9517 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9518 ecode2 = SWIG_AsVal_int(obj1, &val2);
9519 if (!SWIG_IsOK(ecode2)) {
9520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9521 }
9522 arg2 = static_cast< int >(val2);
9523 if (obj2) {
9524 ecode3 = SWIG_AsVal_int(obj2, &val3);
9525 if (!SWIG_IsOK(ecode3)) {
9526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9527 }
9528 arg3 = static_cast< int >(val3);
9529 }
9530 if (obj3) {
9531 ecode4 = SWIG_AsVal_int(obj3, &val4);
9532 if (!SWIG_IsOK(ecode4)) {
9533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9534 }
9535 arg4 = static_cast< int >(val4);
9536 }
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9551 PyObject *resultobj = 0;
9552 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 PyObject *swig_obj[1] ;
9556
9557 if (!args) SWIG_fail;
9558 swig_obj[0] = args;
9559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9562 }
9563 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 delete arg1;
9567
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 resultobj = SWIG_Py_Void();
9572 return resultobj;
9573 fail:
9574 return NULL;
9575 }
9576
9577
9578 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9579 PyObject *resultobj = 0;
9580 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9581 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9582 void *argp1 = 0 ;
9583 int res1 = 0 ;
9584 void *argp2 = 0 ;
9585 int res2 = 0 ;
9586 PyObject * obj0 = 0 ;
9587 PyObject * obj1 = 0 ;
9588 char * kwnames[] = {
9589 (char *) "self",(char *) "table", NULL
9590 };
9591
9592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9594 if (!SWIG_IsOK(res1)) {
9595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9596 }
9597 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9599 if (!SWIG_IsOK(res2)) {
9600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9601 }
9602 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9603 {
9604 PyThreadState* __tstate = wxPyBeginAllowThreads();
9605 (arg1)->SetTableObject(arg2);
9606 wxPyEndAllowThreads(__tstate);
9607 if (PyErr_Occurred()) SWIG_fail;
9608 }
9609 resultobj = SWIG_Py_Void();
9610 return resultobj;
9611 fail:
9612 return NULL;
9613 }
9614
9615
9616 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9617 PyObject *resultobj = 0;
9618 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9619 wxGridTableBase *result = 0 ;
9620 void *argp1 = 0 ;
9621 int res1 = 0 ;
9622 PyObject *swig_obj[1] ;
9623
9624 if (!args) SWIG_fail;
9625 swig_obj[0] = args;
9626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9627 if (!SWIG_IsOK(res1)) {
9628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9629 }
9630 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9631 {
9632 PyThreadState* __tstate = wxPyBeginAllowThreads();
9633 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 {
9638 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9639 }
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(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 *) "id", NULL
9658 };
9659
9660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",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_SetId" "', 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_SetId" "', expected argument " "2"" of type '" "int""'");
9669 }
9670 arg2 = static_cast< int >(val2);
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 (arg1)->SetId(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_GetId(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_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9697 }
9698 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 result = (int)(arg1)->GetId();
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_SetCommandInt(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 *) "comInt1", NULL
9724 };
9725
9726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",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_SetCommandInt" "', 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_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9735 }
9736 arg2 = static_cast< int >(val2);
9737 {
9738 PyThreadState* __tstate = wxPyBeginAllowThreads();
9739 (arg1)->SetCommandInt(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_GetCommandInt(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_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9763 }
9764 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (int)(arg1)->GetCommandInt();
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 *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj = 0;
9780 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9781 int arg2 ;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 int val2 ;
9785 int ecode2 = 0 ;
9786 PyObject * obj0 = 0 ;
9787 PyObject * obj1 = 0 ;
9788 char * kwnames[] = {
9789 (char *) "self",(char *) "comInt2", NULL
9790 };
9791
9792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9794 if (!SWIG_IsOK(res1)) {
9795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9796 }
9797 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9798 ecode2 = SWIG_AsVal_int(obj1, &val2);
9799 if (!SWIG_IsOK(ecode2)) {
9800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9801 }
9802 arg2 = static_cast< int >(val2);
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 (arg1)->SetCommandInt2(arg2);
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_Py_Void();
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9819 int result;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 PyObject *swig_obj[1] ;
9823
9824 if (!args) SWIG_fail;
9825 swig_obj[0] = args;
9826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9829 }
9830 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 result = (int)(arg1)->GetCommandInt2();
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_From_int(static_cast< int >(result));
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *obj;
9846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9847 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9848 return SWIG_Py_Void();
9849 }
9850
9851 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9852 return SWIG_Python_InitShadowInstance(args);
9853 }
9854
9855 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj = 0;
9857 int arg1 = (int) -1 ;
9858 int arg2 = (int) -1 ;
9859 wxGridCellCoords *result = 0 ;
9860 int val1 ;
9861 int ecode1 = 0 ;
9862 int val2 ;
9863 int ecode2 = 0 ;
9864 PyObject * obj0 = 0 ;
9865 PyObject * obj1 = 0 ;
9866 char * kwnames[] = {
9867 (char *) "r",(char *) "c", NULL
9868 };
9869
9870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9871 if (obj0) {
9872 ecode1 = SWIG_AsVal_int(obj0, &val1);
9873 if (!SWIG_IsOK(ecode1)) {
9874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9875 }
9876 arg1 = static_cast< int >(val1);
9877 }
9878 if (obj1) {
9879 ecode2 = SWIG_AsVal_int(obj1, &val2);
9880 if (!SWIG_IsOK(ecode2)) {
9881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9882 }
9883 arg2 = static_cast< int >(val2);
9884 }
9885 {
9886 PyThreadState* __tstate = wxPyBeginAllowThreads();
9887 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9888 wxPyEndAllowThreads(__tstate);
9889 if (PyErr_Occurred()) SWIG_fail;
9890 }
9891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 PyObject *resultobj = 0;
9900 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9901 void *argp1 = 0 ;
9902 int res1 = 0 ;
9903 PyObject *swig_obj[1] ;
9904
9905 if (!args) SWIG_fail;
9906 swig_obj[0] = args;
9907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9908 if (!SWIG_IsOK(res1)) {
9909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9910 }
9911 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 delete arg1;
9915
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_GetRow(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_GetRow" "', 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)->GetRow();
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_SetRow(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_SetRow",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_SetRow" "', 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_SetRow" "', expected argument " "2"" of type '" "int""'");
9977 }
9978 arg2 = static_cast< int >(val2);
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 (arg1)->SetRow(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_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9995 int result;
9996 void *argp1 = 0 ;
9997 int res1 = 0 ;
9998 PyObject *swig_obj[1] ;
9999
10000 if (!args) SWIG_fail;
10001 swig_obj[0] = args;
10002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10003 if (!SWIG_IsOK(res1)) {
10004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10005 }
10006 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_From_int(static_cast< int >(result));
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10021 PyObject *resultobj = 0;
10022 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10023 int arg2 ;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 int val2 ;
10027 int ecode2 = 0 ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char * kwnames[] = {
10031 (char *) "self",(char *) "n", NULL
10032 };
10033
10034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10036 if (!SWIG_IsOK(res1)) {
10037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10038 }
10039 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10040 ecode2 = SWIG_AsVal_int(obj1, &val2);
10041 if (!SWIG_IsOK(ecode2)) {
10042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10043 }
10044 arg2 = static_cast< int >(val2);
10045 {
10046 PyThreadState* __tstate = wxPyBeginAllowThreads();
10047 (arg1)->SetCol(arg2);
10048 wxPyEndAllowThreads(__tstate);
10049 if (PyErr_Occurred()) SWIG_fail;
10050 }
10051 resultobj = SWIG_Py_Void();
10052 return resultobj;
10053 fail:
10054 return NULL;
10055 }
10056
10057
10058 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj = 0;
10060 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10061 int arg2 ;
10062 int arg3 ;
10063 void *argp1 = 0 ;
10064 int res1 = 0 ;
10065 int val2 ;
10066 int ecode2 = 0 ;
10067 int val3 ;
10068 int ecode3 = 0 ;
10069 PyObject * obj0 = 0 ;
10070 PyObject * obj1 = 0 ;
10071 PyObject * obj2 = 0 ;
10072 char * kwnames[] = {
10073 (char *) "self",(char *) "row",(char *) "col", NULL
10074 };
10075
10076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10078 if (!SWIG_IsOK(res1)) {
10079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10080 }
10081 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10082 ecode2 = SWIG_AsVal_int(obj1, &val2);
10083 if (!SWIG_IsOK(ecode2)) {
10084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10085 }
10086 arg2 = static_cast< int >(val2);
10087 ecode3 = SWIG_AsVal_int(obj2, &val3);
10088 if (!SWIG_IsOK(ecode3)) {
10089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10090 }
10091 arg3 = static_cast< int >(val3);
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 (arg1)->Set(arg2,arg3);
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 resultobj = SWIG_Py_Void();
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj = 0;
10107 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10108 PyObject *arg2 = (PyObject *) 0 ;
10109 bool result;
10110 void *argp1 = 0 ;
10111 int res1 = 0 ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 char * kwnames[] = {
10115 (char *) "self",(char *) "other", NULL
10116 };
10117
10118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10120 if (!SWIG_IsOK(res1)) {
10121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10122 }
10123 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10124 arg2 = obj1;
10125 {
10126 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 {
10130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10131 }
10132 return resultobj;
10133 fail:
10134 return NULL;
10135 }
10136
10137
10138 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10139 PyObject *resultobj = 0;
10140 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10141 PyObject *arg2 = (PyObject *) 0 ;
10142 bool result;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 PyObject * obj0 = 0 ;
10146 PyObject * obj1 = 0 ;
10147 char * kwnames[] = {
10148 (char *) "self",(char *) "other", NULL
10149 };
10150
10151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10153 if (!SWIG_IsOK(res1)) {
10154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10155 }
10156 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10157 arg2 = obj1;
10158 {
10159 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 {
10163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10164 }
10165 return resultobj;
10166 fail:
10167 return NULL;
10168 }
10169
10170
10171 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10172 PyObject *resultobj = 0;
10173 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10174 PyObject *result = 0 ;
10175 void *argp1 = 0 ;
10176 int res1 = 0 ;
10177 PyObject *swig_obj[1] ;
10178
10179 if (!args) SWIG_fail;
10180 swig_obj[0] = args;
10181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10182 if (!SWIG_IsOK(res1)) {
10183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10184 }
10185 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 result = (PyObject *)wxGridCellCoords_Get(arg1);
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 resultobj = result;
10193 return resultobj;
10194 fail:
10195 return NULL;
10196 }
10197
10198
10199 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200 PyObject *obj;
10201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10202 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10203 return SWIG_Py_Void();
10204 }
10205
10206 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10207 return SWIG_Python_InitShadowInstance(args);
10208 }
10209
10210 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj = 0;
10212 wxWindow *arg1 = (wxWindow *) 0 ;
10213 int arg2 = (int) -1 ;
10214 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10215 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10216 wxSize const &arg4_defvalue = wxDefaultSize ;
10217 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10218 long arg5 = (long) wxWANTS_CHARS ;
10219 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10220 wxString *arg6 = (wxString *) &arg6_defvalue ;
10221 wxGrid *result = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 int val2 ;
10225 int ecode2 = 0 ;
10226 wxPoint temp3 ;
10227 wxSize temp4 ;
10228 long val5 ;
10229 int ecode5 = 0 ;
10230 bool temp6 = false ;
10231 PyObject * obj0 = 0 ;
10232 PyObject * obj1 = 0 ;
10233 PyObject * obj2 = 0 ;
10234 PyObject * obj3 = 0 ;
10235 PyObject * obj4 = 0 ;
10236 PyObject * obj5 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10245 }
10246 arg1 = reinterpret_cast< wxWindow * >(argp1);
10247 if (obj1) {
10248 ecode2 = SWIG_AsVal_int(obj1, &val2);
10249 if (!SWIG_IsOK(ecode2)) {
10250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10251 }
10252 arg2 = static_cast< int >(val2);
10253 }
10254 if (obj2) {
10255 {
10256 arg3 = &temp3;
10257 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10258 }
10259 }
10260 if (obj3) {
10261 {
10262 arg4 = &temp4;
10263 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10264 }
10265 }
10266 if (obj4) {
10267 ecode5 = SWIG_AsVal_long(obj4, &val5);
10268 if (!SWIG_IsOK(ecode5)) {
10269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10270 }
10271 arg5 = static_cast< long >(val5);
10272 }
10273 if (obj5) {
10274 {
10275 arg6 = wxString_in_helper(obj5);
10276 if (arg6 == NULL) SWIG_fail;
10277 temp6 = true;
10278 }
10279 }
10280 {
10281 if (!wxPyCheckForApp()) SWIG_fail;
10282 PyThreadState* __tstate = wxPyBeginAllowThreads();
10283 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10284 wxPyEndAllowThreads(__tstate);
10285 if (PyErr_Occurred()) SWIG_fail;
10286 }
10287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10288 {
10289 if (temp6)
10290 delete arg6;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp6)
10296 delete arg6;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10303 PyObject *resultobj = 0;
10304 wxGrid *result = 0 ;
10305
10306 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10307 {
10308 if (!wxPyCheckForApp()) SWIG_fail;
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 result = (wxGrid *)new wxGrid();
10311 wxPyEndAllowThreads(__tstate);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj = 0;
10323 wxGrid *arg1 = (wxGrid *) 0 ;
10324 wxWindow *arg2 = (wxWindow *) 0 ;
10325 int arg3 = (int) -1 ;
10326 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10327 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10328 wxSize const &arg5_defvalue = wxDefaultSize ;
10329 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10330 long arg6 = (long) wxWANTS_CHARS ;
10331 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10332 wxString *arg7 = (wxString *) &arg7_defvalue ;
10333 bool result;
10334 void *argp1 = 0 ;
10335 int res1 = 0 ;
10336 void *argp2 = 0 ;
10337 int res2 = 0 ;
10338 int val3 ;
10339 int ecode3 = 0 ;
10340 wxPoint temp4 ;
10341 wxSize temp5 ;
10342 long val6 ;
10343 int ecode6 = 0 ;
10344 bool temp7 = false ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 PyObject * obj2 = 0 ;
10348 PyObject * obj3 = 0 ;
10349 PyObject * obj4 = 0 ;
10350 PyObject * obj5 = 0 ;
10351 PyObject * obj6 = 0 ;
10352 char * kwnames[] = {
10353 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10354 };
10355
10356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10358 if (!SWIG_IsOK(res1)) {
10359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10360 }
10361 arg1 = reinterpret_cast< wxGrid * >(argp1);
10362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10363 if (!SWIG_IsOK(res2)) {
10364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10365 }
10366 arg2 = reinterpret_cast< wxWindow * >(argp2);
10367 if (obj2) {
10368 ecode3 = SWIG_AsVal_int(obj2, &val3);
10369 if (!SWIG_IsOK(ecode3)) {
10370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10371 }
10372 arg3 = static_cast< int >(val3);
10373 }
10374 if (obj3) {
10375 {
10376 arg4 = &temp4;
10377 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10378 }
10379 }
10380 if (obj4) {
10381 {
10382 arg5 = &temp5;
10383 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10384 }
10385 }
10386 if (obj5) {
10387 ecode6 = SWIG_AsVal_long(obj5, &val6);
10388 if (!SWIG_IsOK(ecode6)) {
10389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10390 }
10391 arg6 = static_cast< long >(val6);
10392 }
10393 if (obj6) {
10394 {
10395 arg7 = wxString_in_helper(obj6);
10396 if (arg7 == NULL) SWIG_fail;
10397 temp7 = true;
10398 }
10399 }
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 {
10407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10408 }
10409 {
10410 if (temp7)
10411 delete arg7;
10412 }
10413 return resultobj;
10414 fail:
10415 {
10416 if (temp7)
10417 delete arg7;
10418 }
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxGrid *arg1 = (wxGrid *) 0 ;
10426 int arg2 ;
10427 int arg3 ;
10428 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10429 bool result;
10430 void *argp1 = 0 ;
10431 int res1 = 0 ;
10432 int val2 ;
10433 int ecode2 = 0 ;
10434 int val3 ;
10435 int ecode3 = 0 ;
10436 int val4 ;
10437 int ecode4 = 0 ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440 PyObject * obj2 = 0 ;
10441 PyObject * obj3 = 0 ;
10442 char * kwnames[] = {
10443 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10444 };
10445
10446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10448 if (!SWIG_IsOK(res1)) {
10449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10450 }
10451 arg1 = reinterpret_cast< wxGrid * >(argp1);
10452 ecode2 = SWIG_AsVal_int(obj1, &val2);
10453 if (!SWIG_IsOK(ecode2)) {
10454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10455 }
10456 arg2 = static_cast< int >(val2);
10457 ecode3 = SWIG_AsVal_int(obj2, &val3);
10458 if (!SWIG_IsOK(ecode3)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10460 }
10461 arg3 = static_cast< int >(val3);
10462 if (obj3) {
10463 ecode4 = SWIG_AsVal_int(obj3, &val4);
10464 if (!SWIG_IsOK(ecode4)) {
10465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10466 }
10467 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10468 }
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10485 PyObject *resultobj = 0;
10486 wxGrid *arg1 = (wxGrid *) 0 ;
10487 WXGRIDSELECTIONMODES arg2 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 int val2 ;
10491 int ecode2 = 0 ;
10492 PyObject * obj0 = 0 ;
10493 PyObject * obj1 = 0 ;
10494 char * kwnames[] = {
10495 (char *) "self",(char *) "selmode", NULL
10496 };
10497
10498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10500 if (!SWIG_IsOK(res1)) {
10501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10502 }
10503 arg1 = reinterpret_cast< wxGrid * >(argp1);
10504 ecode2 = SWIG_AsVal_int(obj1, &val2);
10505 if (!SWIG_IsOK(ecode2)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10507 }
10508 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 (arg1)->SetSelectionMode(arg2);
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_Py_Void();
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 PyObject *resultobj = 0;
10524 wxGrid *arg1 = (wxGrid *) 0 ;
10525 WXGRIDSELECTIONMODES result;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 PyObject *swig_obj[1] ;
10529
10530 if (!args) SWIG_fail;
10531 swig_obj[0] = args;
10532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10533 if (!SWIG_IsOK(res1)) {
10534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10535 }
10536 arg1 = reinterpret_cast< wxGrid * >(argp1);
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 resultobj = SWIG_From_int(static_cast< int >(result));
10544 return resultobj;
10545 fail:
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10551 PyObject *resultobj = 0;
10552 wxGrid *arg1 = (wxGrid *) 0 ;
10553 int result;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 PyObject *swig_obj[1] ;
10557
10558 if (!args) SWIG_fail;
10559 swig_obj[0] = args;
10560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10563 }
10564 arg1 = reinterpret_cast< wxGrid * >(argp1);
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (int)(arg1)->GetNumberRows();
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 resultobj = SWIG_From_int(static_cast< int >(result));
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxGrid *arg1 = (wxGrid *) 0 ;
10581 int result;
10582 void *argp1 = 0 ;
10583 int res1 = 0 ;
10584 PyObject *swig_obj[1] ;
10585
10586 if (!args) SWIG_fail;
10587 swig_obj[0] = args;
10588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10589 if (!SWIG_IsOK(res1)) {
10590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10591 }
10592 arg1 = reinterpret_cast< wxGrid * >(argp1);
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (int)(arg1)->GetNumberCols();
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 resultobj = SWIG_From_int(static_cast< int >(result));
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj = 0;
10608 wxGrid *arg1 = (wxGrid *) 0 ;
10609 wxGridTableMessage *arg2 = 0 ;
10610 bool result;
10611 void *argp1 = 0 ;
10612 int res1 = 0 ;
10613 void *argp2 = 0 ;
10614 int res2 = 0 ;
10615 PyObject * obj0 = 0 ;
10616 PyObject * obj1 = 0 ;
10617 char * kwnames[] = {
10618 (char *) "self",(char *)"arg2", NULL
10619 };
10620
10621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10623 if (!SWIG_IsOK(res1)) {
10624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10625 }
10626 arg1 = reinterpret_cast< wxGrid * >(argp1);
10627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10628 if (!SWIG_IsOK(res2)) {
10629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10630 }
10631 if (!argp2) {
10632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10633 }
10634 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10635 {
10636 PyThreadState* __tstate = wxPyBeginAllowThreads();
10637 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 {
10642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10651 PyObject *resultobj = 0;
10652 wxGrid *arg1 = (wxGrid *) 0 ;
10653 wxGridTableBase *result = 0 ;
10654 void *argp1 = 0 ;
10655 int res1 = 0 ;
10656 PyObject *swig_obj[1] ;
10657
10658 if (!args) SWIG_fail;
10659 swig_obj[0] = args;
10660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10661 if (!SWIG_IsOK(res1)) {
10662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10663 }
10664 arg1 = reinterpret_cast< wxGrid * >(argp1);
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 {
10672 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10673 }
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = 0;
10682 wxGrid *arg1 = (wxGrid *) 0 ;
10683 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10684 bool arg3 = (bool) false ;
10685 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10686 bool result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 int res2 = 0 ;
10690 bool val3 ;
10691 int ecode3 = 0 ;
10692 int val4 ;
10693 int ecode4 = 0 ;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 PyObject * obj3 = 0 ;
10698 char * kwnames[] = {
10699 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10700 };
10701
10702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10704 if (!SWIG_IsOK(res1)) {
10705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10706 }
10707 arg1 = reinterpret_cast< wxGrid * >(argp1);
10708 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10709 if (!SWIG_IsOK(res2)) {
10710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10711 }
10712 if (obj2) {
10713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10714 if (!SWIG_IsOK(ecode3)) {
10715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10716 }
10717 arg3 = static_cast< bool >(val3);
10718 }
10719 if (obj3) {
10720 ecode4 = SWIG_AsVal_int(obj3, &val4);
10721 if (!SWIG_IsOK(ecode4)) {
10722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10723 }
10724 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10734 }
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10742 PyObject *resultobj = 0;
10743 wxGrid *arg1 = (wxGrid *) 0 ;
10744 void *argp1 = 0 ;
10745 int res1 = 0 ;
10746 PyObject *swig_obj[1] ;
10747
10748 if (!args) SWIG_fail;
10749 swig_obj[0] = args;
10750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10751 if (!SWIG_IsOK(res1)) {
10752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10753 }
10754 arg1 = reinterpret_cast< wxGrid * >(argp1);
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 (arg1)->ClearGrid();
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 resultobj = SWIG_Py_Void();
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10769 PyObject *resultobj = 0;
10770 wxGrid *arg1 = (wxGrid *) 0 ;
10771 int arg2 = (int) 0 ;
10772 int arg3 = (int) 1 ;
10773 bool arg4 = (bool) true ;
10774 bool result;
10775 void *argp1 = 0 ;
10776 int res1 = 0 ;
10777 int val2 ;
10778 int ecode2 = 0 ;
10779 int val3 ;
10780 int ecode3 = 0 ;
10781 bool val4 ;
10782 int ecode4 = 0 ;
10783 PyObject * obj0 = 0 ;
10784 PyObject * obj1 = 0 ;
10785 PyObject * obj2 = 0 ;
10786 PyObject * obj3 = 0 ;
10787 char * kwnames[] = {
10788 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10789 };
10790
10791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10793 if (!SWIG_IsOK(res1)) {
10794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10795 }
10796 arg1 = reinterpret_cast< wxGrid * >(argp1);
10797 if (obj1) {
10798 ecode2 = SWIG_AsVal_int(obj1, &val2);
10799 if (!SWIG_IsOK(ecode2)) {
10800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10801 }
10802 arg2 = static_cast< int >(val2);
10803 }
10804 if (obj2) {
10805 ecode3 = SWIG_AsVal_int(obj2, &val3);
10806 if (!SWIG_IsOK(ecode3)) {
10807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10808 }
10809 arg3 = static_cast< int >(val3);
10810 }
10811 if (obj3) {
10812 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10813 if (!SWIG_IsOK(ecode4)) {
10814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10815 }
10816 arg4 = static_cast< bool >(val4);
10817 }
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 {
10825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10826 }
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj = 0;
10835 wxGrid *arg1 = (wxGrid *) 0 ;
10836 int arg2 = (int) 1 ;
10837 bool arg3 = (bool) true ;
10838 bool result;
10839 void *argp1 = 0 ;
10840 int res1 = 0 ;
10841 int val2 ;
10842 int ecode2 = 0 ;
10843 bool val3 ;
10844 int ecode3 = 0 ;
10845 PyObject * obj0 = 0 ;
10846 PyObject * obj1 = 0 ;
10847 PyObject * obj2 = 0 ;
10848 char * kwnames[] = {
10849 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10850 };
10851
10852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10854 if (!SWIG_IsOK(res1)) {
10855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10856 }
10857 arg1 = reinterpret_cast< wxGrid * >(argp1);
10858 if (obj1) {
10859 ecode2 = SWIG_AsVal_int(obj1, &val2);
10860 if (!SWIG_IsOK(ecode2)) {
10861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10862 }
10863 arg2 = static_cast< int >(val2);
10864 }
10865 if (obj2) {
10866 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10867 if (!SWIG_IsOK(ecode3)) {
10868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10869 }
10870 arg3 = static_cast< bool >(val3);
10871 }
10872 {
10873 PyThreadState* __tstate = wxPyBeginAllowThreads();
10874 result = (bool)(arg1)->AppendRows(arg2,arg3);
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 {
10879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10880 }
10881 return resultobj;
10882 fail:
10883 return NULL;
10884 }
10885
10886
10887 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10888 PyObject *resultobj = 0;
10889 wxGrid *arg1 = (wxGrid *) 0 ;
10890 int arg2 = (int) 0 ;
10891 int arg3 = (int) 1 ;
10892 bool arg4 = (bool) true ;
10893 bool result;
10894 void *argp1 = 0 ;
10895 int res1 = 0 ;
10896 int val2 ;
10897 int ecode2 = 0 ;
10898 int val3 ;
10899 int ecode3 = 0 ;
10900 bool val4 ;
10901 int ecode4 = 0 ;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 PyObject * obj2 = 0 ;
10905 PyObject * obj3 = 0 ;
10906 char * kwnames[] = {
10907 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10908 };
10909
10910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10912 if (!SWIG_IsOK(res1)) {
10913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10914 }
10915 arg1 = reinterpret_cast< wxGrid * >(argp1);
10916 if (obj1) {
10917 ecode2 = SWIG_AsVal_int(obj1, &val2);
10918 if (!SWIG_IsOK(ecode2)) {
10919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10920 }
10921 arg2 = static_cast< int >(val2);
10922 }
10923 if (obj2) {
10924 ecode3 = SWIG_AsVal_int(obj2, &val3);
10925 if (!SWIG_IsOK(ecode3)) {
10926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10927 }
10928 arg3 = static_cast< int >(val3);
10929 }
10930 if (obj3) {
10931 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10932 if (!SWIG_IsOK(ecode4)) {
10933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10934 }
10935 arg4 = static_cast< bool >(val4);
10936 }
10937 {
10938 PyThreadState* __tstate = wxPyBeginAllowThreads();
10939 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 {
10944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10945 }
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = 0;
10954 wxGrid *arg1 = (wxGrid *) 0 ;
10955 int arg2 = (int) 0 ;
10956 int arg3 = (int) 1 ;
10957 bool arg4 = (bool) true ;
10958 bool result;
10959 void *argp1 = 0 ;
10960 int res1 = 0 ;
10961 int val2 ;
10962 int ecode2 = 0 ;
10963 int val3 ;
10964 int ecode3 = 0 ;
10965 bool val4 ;
10966 int ecode4 = 0 ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 PyObject * obj2 = 0 ;
10970 PyObject * obj3 = 0 ;
10971 char * kwnames[] = {
10972 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10973 };
10974
10975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10977 if (!SWIG_IsOK(res1)) {
10978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10979 }
10980 arg1 = reinterpret_cast< wxGrid * >(argp1);
10981 if (obj1) {
10982 ecode2 = SWIG_AsVal_int(obj1, &val2);
10983 if (!SWIG_IsOK(ecode2)) {
10984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10985 }
10986 arg2 = static_cast< int >(val2);
10987 }
10988 if (obj2) {
10989 ecode3 = SWIG_AsVal_int(obj2, &val3);
10990 if (!SWIG_IsOK(ecode3)) {
10991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10992 }
10993 arg3 = static_cast< int >(val3);
10994 }
10995 if (obj3) {
10996 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10997 if (!SWIG_IsOK(ecode4)) {
10998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10999 }
11000 arg4 = static_cast< bool >(val4);
11001 }
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj = 0;
11019 wxGrid *arg1 = (wxGrid *) 0 ;
11020 int arg2 = (int) 1 ;
11021 bool arg3 = (bool) true ;
11022 bool result;
11023 void *argp1 = 0 ;
11024 int res1 = 0 ;
11025 int val2 ;
11026 int ecode2 = 0 ;
11027 bool val3 ;
11028 int ecode3 = 0 ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 PyObject * obj2 = 0 ;
11032 char * kwnames[] = {
11033 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11034 };
11035
11036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11038 if (!SWIG_IsOK(res1)) {
11039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11040 }
11041 arg1 = reinterpret_cast< wxGrid * >(argp1);
11042 if (obj1) {
11043 ecode2 = SWIG_AsVal_int(obj1, &val2);
11044 if (!SWIG_IsOK(ecode2)) {
11045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11046 }
11047 arg2 = static_cast< int >(val2);
11048 }
11049 if (obj2) {
11050 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11051 if (!SWIG_IsOK(ecode3)) {
11052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11053 }
11054 arg3 = static_cast< bool >(val3);
11055 }
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 result = (bool)(arg1)->AppendCols(arg2,arg3);
11059 wxPyEndAllowThreads(__tstate);
11060 if (PyErr_Occurred()) SWIG_fail;
11061 }
11062 {
11063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11064 }
11065 return resultobj;
11066 fail:
11067 return NULL;
11068 }
11069
11070
11071 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11072 PyObject *resultobj = 0;
11073 wxGrid *arg1 = (wxGrid *) 0 ;
11074 int arg2 = (int) 0 ;
11075 int arg3 = (int) 1 ;
11076 bool arg4 = (bool) true ;
11077 bool result;
11078 void *argp1 = 0 ;
11079 int res1 = 0 ;
11080 int val2 ;
11081 int ecode2 = 0 ;
11082 int val3 ;
11083 int ecode3 = 0 ;
11084 bool val4 ;
11085 int ecode4 = 0 ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 PyObject * obj2 = 0 ;
11089 PyObject * obj3 = 0 ;
11090 char * kwnames[] = {
11091 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11092 };
11093
11094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11096 if (!SWIG_IsOK(res1)) {
11097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11098 }
11099 arg1 = reinterpret_cast< wxGrid * >(argp1);
11100 if (obj1) {
11101 ecode2 = SWIG_AsVal_int(obj1, &val2);
11102 if (!SWIG_IsOK(ecode2)) {
11103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11104 }
11105 arg2 = static_cast< int >(val2);
11106 }
11107 if (obj2) {
11108 ecode3 = SWIG_AsVal_int(obj2, &val3);
11109 if (!SWIG_IsOK(ecode3)) {
11110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11111 }
11112 arg3 = static_cast< int >(val3);
11113 }
11114 if (obj3) {
11115 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11116 if (!SWIG_IsOK(ecode4)) {
11117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11118 }
11119 arg4 = static_cast< bool >(val4);
11120 }
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 {
11128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11129 }
11130 return resultobj;
11131 fail:
11132 return NULL;
11133 }
11134
11135
11136 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11137 PyObject *resultobj = 0;
11138 wxGrid *arg1 = (wxGrid *) 0 ;
11139 wxDC *arg2 = 0 ;
11140 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 void *argp2 = 0 ;
11144 int res2 = 0 ;
11145 void *argp3 = 0 ;
11146 int res3 = 0 ;
11147 PyObject * obj0 = 0 ;
11148 PyObject * obj1 = 0 ;
11149 PyObject * obj2 = 0 ;
11150 char * kwnames[] = {
11151 (char *) "self",(char *) "dc",(char *) "attr", NULL
11152 };
11153
11154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11156 if (!SWIG_IsOK(res1)) {
11157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11158 }
11159 arg1 = reinterpret_cast< wxGrid * >(argp1);
11160 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11161 if (!SWIG_IsOK(res2)) {
11162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11163 }
11164 if (!argp2) {
11165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11166 }
11167 arg2 = reinterpret_cast< wxDC * >(argp2);
11168 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11169 if (!SWIG_IsOK(res3)) {
11170 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11171 }
11172 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 resultobj = SWIG_Py_Void();
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11187 PyObject *resultobj = 0;
11188 wxGrid *arg1 = (wxGrid *) 0 ;
11189 wxDC *arg2 = 0 ;
11190 wxString *arg3 = 0 ;
11191 wxRect *arg4 = 0 ;
11192 int arg5 = (int) wxLEFT ;
11193 int arg6 = (int) wxTOP ;
11194 int arg7 = (int) wxHORIZONTAL ;
11195 void *argp1 = 0 ;
11196 int res1 = 0 ;
11197 void *argp2 = 0 ;
11198 int res2 = 0 ;
11199 bool temp3 = false ;
11200 wxRect temp4 ;
11201 int val5 ;
11202 int ecode5 = 0 ;
11203 int val6 ;
11204 int ecode6 = 0 ;
11205 int val7 ;
11206 int ecode7 = 0 ;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 PyObject * obj2 = 0 ;
11210 PyObject * obj3 = 0 ;
11211 PyObject * obj4 = 0 ;
11212 PyObject * obj5 = 0 ;
11213 PyObject * obj6 = 0 ;
11214 char * kwnames[] = {
11215 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11216 };
11217
11218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11220 if (!SWIG_IsOK(res1)) {
11221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11222 }
11223 arg1 = reinterpret_cast< wxGrid * >(argp1);
11224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11225 if (!SWIG_IsOK(res2)) {
11226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11227 }
11228 if (!argp2) {
11229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11230 }
11231 arg2 = reinterpret_cast< wxDC * >(argp2);
11232 {
11233 arg3 = wxString_in_helper(obj2);
11234 if (arg3 == NULL) SWIG_fail;
11235 temp3 = true;
11236 }
11237 {
11238 arg4 = &temp4;
11239 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11240 }
11241 if (obj4) {
11242 ecode5 = SWIG_AsVal_int(obj4, &val5);
11243 if (!SWIG_IsOK(ecode5)) {
11244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11245 }
11246 arg5 = static_cast< int >(val5);
11247 }
11248 if (obj5) {
11249 ecode6 = SWIG_AsVal_int(obj5, &val6);
11250 if (!SWIG_IsOK(ecode6)) {
11251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11252 }
11253 arg6 = static_cast< int >(val6);
11254 }
11255 if (obj6) {
11256 ecode7 = SWIG_AsVal_int(obj6, &val7);
11257 if (!SWIG_IsOK(ecode7)) {
11258 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11259 }
11260 arg7 = static_cast< int >(val7);
11261 }
11262 {
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 resultobj = SWIG_Py_Void();
11269 {
11270 if (temp3)
11271 delete arg3;
11272 }
11273 return resultobj;
11274 fail:
11275 {
11276 if (temp3)
11277 delete arg3;
11278 }
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj = 0;
11285 wxGrid *arg1 = (wxGrid *) 0 ;
11286 wxDC *arg2 = 0 ;
11287 wxArrayString *arg3 = 0 ;
11288 long *arg4 = (long *) 0 ;
11289 long *arg5 = (long *) 0 ;
11290 void *argp1 = 0 ;
11291 int res1 = 0 ;
11292 void *argp2 = 0 ;
11293 int res2 = 0 ;
11294 bool temp3 = false ;
11295 long temp4 ;
11296 int res4 = SWIG_TMPOBJ ;
11297 long temp5 ;
11298 int res5 = SWIG_TMPOBJ ;
11299 PyObject * obj0 = 0 ;
11300 PyObject * obj1 = 0 ;
11301 PyObject * obj2 = 0 ;
11302 char * kwnames[] = {
11303 (char *) "self",(char *) "dc",(char *) "lines", NULL
11304 };
11305
11306 arg4 = &temp4;
11307 arg5 = &temp5;
11308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11310 if (!SWIG_IsOK(res1)) {
11311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11312 }
11313 arg1 = reinterpret_cast< wxGrid * >(argp1);
11314 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11315 if (!SWIG_IsOK(res2)) {
11316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11317 }
11318 if (!argp2) {
11319 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11320 }
11321 arg2 = reinterpret_cast< wxDC * >(argp2);
11322 {
11323 if (! PySequence_Check(obj2)) {
11324 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11325 SWIG_fail;
11326 }
11327 arg3 = new wxArrayString;
11328 temp3 = true;
11329 int i, len=PySequence_Length(obj2);
11330 for (i=0; i<len; i++) {
11331 PyObject* item = PySequence_GetItem(obj2, i);
11332 wxString* s = wxString_in_helper(item);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 arg3->Add(*s);
11335 delete s;
11336 Py_DECREF(item);
11337 }
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 resultobj = SWIG_Py_Void();
11346 if (SWIG_IsTmpObj(res4)) {
11347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11348 } else {
11349 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11351 }
11352 if (SWIG_IsTmpObj(res5)) {
11353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11354 } else {
11355 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11357 }
11358 {
11359 if (temp3) delete arg3;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp3) delete arg3;
11365 }
11366 return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 PyObject *resultobj = 0;
11372 wxGrid *arg1 = (wxGrid *) 0 ;
11373 void *argp1 = 0 ;
11374 int res1 = 0 ;
11375 PyObject *swig_obj[1] ;
11376
11377 if (!args) SWIG_fail;
11378 swig_obj[0] = args;
11379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11380 if (!SWIG_IsOK(res1)) {
11381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11382 }
11383 arg1 = reinterpret_cast< wxGrid * >(argp1);
11384 {
11385 PyThreadState* __tstate = wxPyBeginAllowThreads();
11386 (arg1)->BeginBatch();
11387 wxPyEndAllowThreads(__tstate);
11388 if (PyErr_Occurred()) SWIG_fail;
11389 }
11390 resultobj = SWIG_Py_Void();
11391 return resultobj;
11392 fail:
11393 return NULL;
11394 }
11395
11396
11397 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 PyObject *resultobj = 0;
11399 wxGrid *arg1 = (wxGrid *) 0 ;
11400 void *argp1 = 0 ;
11401 int res1 = 0 ;
11402 PyObject *swig_obj[1] ;
11403
11404 if (!args) SWIG_fail;
11405 swig_obj[0] = args;
11406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11407 if (!SWIG_IsOK(res1)) {
11408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11409 }
11410 arg1 = reinterpret_cast< wxGrid * >(argp1);
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 (arg1)->EndBatch();
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 resultobj = SWIG_Py_Void();
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11425 PyObject *resultobj = 0;
11426 wxGrid *arg1 = (wxGrid *) 0 ;
11427 int result;
11428 void *argp1 = 0 ;
11429 int res1 = 0 ;
11430 PyObject *swig_obj[1] ;
11431
11432 if (!args) SWIG_fail;
11433 swig_obj[0] = args;
11434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11435 if (!SWIG_IsOK(res1)) {
11436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11437 }
11438 arg1 = reinterpret_cast< wxGrid * >(argp1);
11439 {
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (int)(arg1)->GetBatchCount();
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 resultobj = SWIG_From_int(static_cast< int >(result));
11446 return resultobj;
11447 fail:
11448 return NULL;
11449 }
11450
11451
11452 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11453 PyObject *resultobj = 0;
11454 wxGrid *arg1 = (wxGrid *) 0 ;
11455 void *argp1 = 0 ;
11456 int res1 = 0 ;
11457 PyObject *swig_obj[1] ;
11458
11459 if (!args) SWIG_fail;
11460 swig_obj[0] = args;
11461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11462 if (!SWIG_IsOK(res1)) {
11463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11464 }
11465 arg1 = reinterpret_cast< wxGrid * >(argp1);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 (arg1)->ForceRefresh();
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 return resultobj;
11474 fail:
11475 return NULL;
11476 }
11477
11478
11479 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11480 PyObject *resultobj = 0;
11481 wxGrid *arg1 = (wxGrid *) 0 ;
11482 bool result;
11483 void *argp1 = 0 ;
11484 int res1 = 0 ;
11485 PyObject *swig_obj[1] ;
11486
11487 if (!args) SWIG_fail;
11488 swig_obj[0] = args;
11489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11492 }
11493 arg1 = reinterpret_cast< wxGrid * >(argp1);
11494 {
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 result = (bool)(arg1)->IsEditable();
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 {
11501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11502 }
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11510 PyObject *resultobj = 0;
11511 wxGrid *arg1 = (wxGrid *) 0 ;
11512 bool arg2 ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 bool val2 ;
11516 int ecode2 = 0 ;
11517 PyObject * obj0 = 0 ;
11518 PyObject * obj1 = 0 ;
11519 char * kwnames[] = {
11520 (char *) "self",(char *) "edit", NULL
11521 };
11522
11523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11527 }
11528 arg1 = reinterpret_cast< wxGrid * >(argp1);
11529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11530 if (!SWIG_IsOK(ecode2)) {
11531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11532 }
11533 arg2 = static_cast< bool >(val2);
11534 {
11535 PyThreadState* __tstate = wxPyBeginAllowThreads();
11536 (arg1)->EnableEditing(arg2);
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11548 PyObject *resultobj = 0;
11549 wxGrid *arg1 = (wxGrid *) 0 ;
11550 bool arg2 = (bool) true ;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 bool val2 ;
11554 int ecode2 = 0 ;
11555 PyObject * obj0 = 0 ;
11556 PyObject * obj1 = 0 ;
11557 char * kwnames[] = {
11558 (char *) "self",(char *) "enable", NULL
11559 };
11560
11561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11563 if (!SWIG_IsOK(res1)) {
11564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11565 }
11566 arg1 = reinterpret_cast< wxGrid * >(argp1);
11567 if (obj1) {
11568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11569 if (!SWIG_IsOK(ecode2)) {
11570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11571 }
11572 arg2 = static_cast< bool >(val2);
11573 }
11574 {
11575 PyThreadState* __tstate = wxPyBeginAllowThreads();
11576 (arg1)->EnableCellEditControl(arg2);
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = SWIG_Py_Void();
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *resultobj = 0;
11589 wxGrid *arg1 = (wxGrid *) 0 ;
11590 void *argp1 = 0 ;
11591 int res1 = 0 ;
11592 PyObject *swig_obj[1] ;
11593
11594 if (!args) SWIG_fail;
11595 swig_obj[0] = args;
11596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11599 }
11600 arg1 = reinterpret_cast< wxGrid * >(argp1);
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 (arg1)->DisableCellEditControl();
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 resultobj = SWIG_Py_Void();
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11615 PyObject *resultobj = 0;
11616 wxGrid *arg1 = (wxGrid *) 0 ;
11617 bool result;
11618 void *argp1 = 0 ;
11619 int res1 = 0 ;
11620 PyObject *swig_obj[1] ;
11621
11622 if (!args) SWIG_fail;
11623 swig_obj[0] = args;
11624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11625 if (!SWIG_IsOK(res1)) {
11626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11627 }
11628 arg1 = reinterpret_cast< wxGrid * >(argp1);
11629 {
11630 PyThreadState* __tstate = wxPyBeginAllowThreads();
11631 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 {
11636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11637 }
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11645 PyObject *resultobj = 0;
11646 wxGrid *arg1 = (wxGrid *) 0 ;
11647 bool result;
11648 void *argp1 = 0 ;
11649 int res1 = 0 ;
11650 PyObject *swig_obj[1] ;
11651
11652 if (!args) SWIG_fail;
11653 swig_obj[0] = args;
11654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11655 if (!SWIG_IsOK(res1)) {
11656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11657 }
11658 arg1 = reinterpret_cast< wxGrid * >(argp1);
11659 {
11660 PyThreadState* __tstate = wxPyBeginAllowThreads();
11661 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11662 wxPyEndAllowThreads(__tstate);
11663 if (PyErr_Occurred()) SWIG_fail;
11664 }
11665 {
11666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11667 }
11668 return resultobj;
11669 fail:
11670 return NULL;
11671 }
11672
11673
11674 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11675 PyObject *resultobj = 0;
11676 wxGrid *arg1 = (wxGrid *) 0 ;
11677 bool result;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 PyObject *swig_obj[1] ;
11681
11682 if (!args) SWIG_fail;
11683 swig_obj[0] = args;
11684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11685 if (!SWIG_IsOK(res1)) {
11686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11687 }
11688 arg1 = reinterpret_cast< wxGrid * >(argp1);
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 {
11696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11697 }
11698 return resultobj;
11699 fail:
11700 return NULL;
11701 }
11702
11703
11704 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11705 PyObject *resultobj = 0;
11706 wxGrid *arg1 = (wxGrid *) 0 ;
11707 bool result;
11708 void *argp1 = 0 ;
11709 int res1 = 0 ;
11710 PyObject *swig_obj[1] ;
11711
11712 if (!args) SWIG_fail;
11713 swig_obj[0] = args;
11714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11715 if (!SWIG_IsOK(res1)) {
11716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11717 }
11718 arg1 = reinterpret_cast< wxGrid * >(argp1);
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxGrid *arg1 = (wxGrid *) 0 ;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11746 }
11747 arg1 = reinterpret_cast< wxGrid * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 (arg1)->ShowCellEditControl();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_Py_Void();
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxGrid *arg1 = (wxGrid *) 0 ;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11773 }
11774 arg1 = reinterpret_cast< wxGrid * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 (arg1)->HideCellEditControl();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_Py_Void();
11782 return resultobj;
11783 fail:
11784 return NULL;
11785 }
11786
11787
11788 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11789 PyObject *resultobj = 0;
11790 wxGrid *arg1 = (wxGrid *) 0 ;
11791 void *argp1 = 0 ;
11792 int res1 = 0 ;
11793 PyObject *swig_obj[1] ;
11794
11795 if (!args) SWIG_fail;
11796 swig_obj[0] = args;
11797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11798 if (!SWIG_IsOK(res1)) {
11799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11800 }
11801 arg1 = reinterpret_cast< wxGrid * >(argp1);
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 (arg1)->SaveEditControlValue();
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 resultobj = SWIG_Py_Void();
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj = 0;
11817 wxGrid *arg1 = (wxGrid *) 0 ;
11818 int arg2 ;
11819 int arg3 ;
11820 wxGridCellCoords result;
11821 void *argp1 = 0 ;
11822 int res1 = 0 ;
11823 int val2 ;
11824 int ecode2 = 0 ;
11825 int val3 ;
11826 int ecode3 = 0 ;
11827 PyObject * obj0 = 0 ;
11828 PyObject * obj1 = 0 ;
11829 PyObject * obj2 = 0 ;
11830 char * kwnames[] = {
11831 (char *) "self",(char *) "x",(char *) "y", NULL
11832 };
11833
11834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11836 if (!SWIG_IsOK(res1)) {
11837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11838 }
11839 arg1 = reinterpret_cast< wxGrid * >(argp1);
11840 ecode2 = SWIG_AsVal_int(obj1, &val2);
11841 if (!SWIG_IsOK(ecode2)) {
11842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11843 }
11844 arg2 = static_cast< int >(val2);
11845 ecode3 = SWIG_AsVal_int(obj2, &val3);
11846 if (!SWIG_IsOK(ecode3)) {
11847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11848 }
11849 arg3 = static_cast< int >(val3);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = wxGrid_XYToCell(arg1,arg2,arg3);
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11864 PyObject *resultobj = 0;
11865 wxGrid *arg1 = (wxGrid *) 0 ;
11866 int arg2 ;
11867 int result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 int val2 ;
11871 int ecode2 = 0 ;
11872 PyObject * obj0 = 0 ;
11873 PyObject * obj1 = 0 ;
11874 char * kwnames[] = {
11875 (char *) "self",(char *) "y", NULL
11876 };
11877
11878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11880 if (!SWIG_IsOK(res1)) {
11881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11882 }
11883 arg1 = reinterpret_cast< wxGrid * >(argp1);
11884 ecode2 = SWIG_AsVal_int(obj1, &val2);
11885 if (!SWIG_IsOK(ecode2)) {
11886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11887 }
11888 arg2 = static_cast< int >(val2);
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (int)(arg1)->YToRow(arg2);
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 resultobj = SWIG_From_int(static_cast< int >(result));
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj = 0;
11904 wxGrid *arg1 = (wxGrid *) 0 ;
11905 int arg2 ;
11906 bool arg3 = (bool) false ;
11907 int result;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 int val2 ;
11911 int ecode2 = 0 ;
11912 bool val3 ;
11913 int ecode3 = 0 ;
11914 PyObject * obj0 = 0 ;
11915 PyObject * obj1 = 0 ;
11916 PyObject * obj2 = 0 ;
11917 char * kwnames[] = {
11918 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11919 };
11920
11921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11923 if (!SWIG_IsOK(res1)) {
11924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11925 }
11926 arg1 = reinterpret_cast< wxGrid * >(argp1);
11927 ecode2 = SWIG_AsVal_int(obj1, &val2);
11928 if (!SWIG_IsOK(ecode2)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11930 }
11931 arg2 = static_cast< int >(val2);
11932 if (obj2) {
11933 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11934 if (!SWIG_IsOK(ecode3)) {
11935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11936 }
11937 arg3 = static_cast< bool >(val3);
11938 }
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (int)(arg1)->XToCol(arg2,arg3);
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 resultobj = SWIG_From_int(static_cast< int >(result));
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj = 0;
11954 wxGrid *arg1 = (wxGrid *) 0 ;
11955 int arg2 ;
11956 int result;
11957 void *argp1 = 0 ;
11958 int res1 = 0 ;
11959 int val2 ;
11960 int ecode2 = 0 ;
11961 PyObject * obj0 = 0 ;
11962 PyObject * obj1 = 0 ;
11963 char * kwnames[] = {
11964 (char *) "self",(char *) "y", NULL
11965 };
11966
11967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11971 }
11972 arg1 = reinterpret_cast< wxGrid * >(argp1);
11973 ecode2 = SWIG_AsVal_int(obj1, &val2);
11974 if (!SWIG_IsOK(ecode2)) {
11975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11976 }
11977 arg2 = static_cast< int >(val2);
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 result = (int)(arg1)->YToEdgeOfRow(arg2);
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 resultobj = SWIG_From_int(static_cast< int >(result));
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj = 0;
11993 wxGrid *arg1 = (wxGrid *) 0 ;
11994 int arg2 ;
11995 int result;
11996 void *argp1 = 0 ;
11997 int res1 = 0 ;
11998 int val2 ;
11999 int ecode2 = 0 ;
12000 PyObject * obj0 = 0 ;
12001 PyObject * obj1 = 0 ;
12002 char * kwnames[] = {
12003 (char *) "self",(char *) "x", NULL
12004 };
12005
12006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12008 if (!SWIG_IsOK(res1)) {
12009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12010 }
12011 arg1 = reinterpret_cast< wxGrid * >(argp1);
12012 ecode2 = SWIG_AsVal_int(obj1, &val2);
12013 if (!SWIG_IsOK(ecode2)) {
12014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12015 }
12016 arg2 = static_cast< int >(val2);
12017 {
12018 PyThreadState* __tstate = wxPyBeginAllowThreads();
12019 result = (int)(arg1)->XToEdgeOfCol(arg2);
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 resultobj = SWIG_From_int(static_cast< int >(result));
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj = 0;
12032 wxGrid *arg1 = (wxGrid *) 0 ;
12033 int arg2 ;
12034 int arg3 ;
12035 wxRect result;
12036 void *argp1 = 0 ;
12037 int res1 = 0 ;
12038 int val2 ;
12039 int ecode2 = 0 ;
12040 int val3 ;
12041 int ecode3 = 0 ;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 PyObject * obj2 = 0 ;
12045 char * kwnames[] = {
12046 (char *) "self",(char *) "row",(char *) "col", NULL
12047 };
12048
12049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12051 if (!SWIG_IsOK(res1)) {
12052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12053 }
12054 arg1 = reinterpret_cast< wxGrid * >(argp1);
12055 ecode2 = SWIG_AsVal_int(obj1, &val2);
12056 if (!SWIG_IsOK(ecode2)) {
12057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12058 }
12059 arg2 = static_cast< int >(val2);
12060 ecode3 = SWIG_AsVal_int(obj2, &val3);
12061 if (!SWIG_IsOK(ecode3)) {
12062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12063 }
12064 arg3 = static_cast< int >(val3);
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 result = (arg1)->CellToRect(arg2,arg3);
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12079 PyObject *resultobj = 0;
12080 wxGrid *arg1 = (wxGrid *) 0 ;
12081 int result;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 PyObject *swig_obj[1] ;
12085
12086 if (!args) SWIG_fail;
12087 swig_obj[0] = args;
12088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12089 if (!SWIG_IsOK(res1)) {
12090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12091 }
12092 arg1 = reinterpret_cast< wxGrid * >(argp1);
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (int)(arg1)->GetGridCursorRow();
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 resultobj = SWIG_From_int(static_cast< int >(result));
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxGrid *arg1 = (wxGrid *) 0 ;
12109 int result;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12119 }
12120 arg1 = reinterpret_cast< wxGrid * >(argp1);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (int)(arg1)->GetGridCursorCol();
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 resultobj = SWIG_From_int(static_cast< int >(result));
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj = 0;
12136 wxGrid *arg1 = (wxGrid *) 0 ;
12137 int arg2 ;
12138 int arg3 ;
12139 bool arg4 = (bool) true ;
12140 bool result;
12141 void *argp1 = 0 ;
12142 int res1 = 0 ;
12143 int val2 ;
12144 int ecode2 = 0 ;
12145 int val3 ;
12146 int ecode3 = 0 ;
12147 bool val4 ;
12148 int ecode4 = 0 ;
12149 PyObject * obj0 = 0 ;
12150 PyObject * obj1 = 0 ;
12151 PyObject * obj2 = 0 ;
12152 PyObject * obj3 = 0 ;
12153 char * kwnames[] = {
12154 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12155 };
12156
12157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12159 if (!SWIG_IsOK(res1)) {
12160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12161 }
12162 arg1 = reinterpret_cast< wxGrid * >(argp1);
12163 ecode2 = SWIG_AsVal_int(obj1, &val2);
12164 if (!SWIG_IsOK(ecode2)) {
12165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12166 }
12167 arg2 = static_cast< int >(val2);
12168 ecode3 = SWIG_AsVal_int(obj2, &val3);
12169 if (!SWIG_IsOK(ecode3)) {
12170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12171 }
12172 arg3 = static_cast< int >(val3);
12173 if (obj3) {
12174 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12175 if (!SWIG_IsOK(ecode4)) {
12176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12177 }
12178 arg4 = static_cast< bool >(val4);
12179 }
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 {
12187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12188 }
12189 return resultobj;
12190 fail:
12191 return NULL;
12192 }
12193
12194
12195 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12196 PyObject *resultobj = 0;
12197 wxGrid *arg1 = (wxGrid *) 0 ;
12198 int arg2 ;
12199 int arg3 ;
12200 void *argp1 = 0 ;
12201 int res1 = 0 ;
12202 int val2 ;
12203 int ecode2 = 0 ;
12204 int val3 ;
12205 int ecode3 = 0 ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 PyObject * obj2 = 0 ;
12209 char * kwnames[] = {
12210 (char *) "self",(char *) "row",(char *) "col", NULL
12211 };
12212
12213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12217 }
12218 arg1 = reinterpret_cast< wxGrid * >(argp1);
12219 ecode2 = SWIG_AsVal_int(obj1, &val2);
12220 if (!SWIG_IsOK(ecode2)) {
12221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12222 }
12223 arg2 = static_cast< int >(val2);
12224 ecode3 = SWIG_AsVal_int(obj2, &val3);
12225 if (!SWIG_IsOK(ecode3)) {
12226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12227 }
12228 arg3 = static_cast< int >(val3);
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 (arg1)->MakeCellVisible(arg2,arg3);
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 resultobj = SWIG_Py_Void();
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj = 0;
12244 wxGrid *arg1 = (wxGrid *) 0 ;
12245 int arg2 ;
12246 int arg3 ;
12247 void *argp1 = 0 ;
12248 int res1 = 0 ;
12249 int val2 ;
12250 int ecode2 = 0 ;
12251 int val3 ;
12252 int ecode3 = 0 ;
12253 PyObject * obj0 = 0 ;
12254 PyObject * obj1 = 0 ;
12255 PyObject * obj2 = 0 ;
12256 char * kwnames[] = {
12257 (char *) "self",(char *) "row",(char *) "col", NULL
12258 };
12259
12260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12262 if (!SWIG_IsOK(res1)) {
12263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12264 }
12265 arg1 = reinterpret_cast< wxGrid * >(argp1);
12266 ecode2 = SWIG_AsVal_int(obj1, &val2);
12267 if (!SWIG_IsOK(ecode2)) {
12268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12269 }
12270 arg2 = static_cast< int >(val2);
12271 ecode3 = SWIG_AsVal_int(obj2, &val3);
12272 if (!SWIG_IsOK(ecode3)) {
12273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12274 }
12275 arg3 = static_cast< int >(val3);
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 (arg1)->SetGridCursor(arg2,arg3);
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_Py_Void();
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 wxGrid *arg1 = (wxGrid *) 0 ;
12292 bool arg2 ;
12293 bool result;
12294 void *argp1 = 0 ;
12295 int res1 = 0 ;
12296 bool val2 ;
12297 int ecode2 = 0 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 char * kwnames[] = {
12301 (char *) "self",(char *) "expandSelection", NULL
12302 };
12303
12304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12306 if (!SWIG_IsOK(res1)) {
12307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12308 }
12309 arg1 = reinterpret_cast< wxGrid * >(argp1);
12310 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12311 if (!SWIG_IsOK(ecode2)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12313 }
12314 arg2 = static_cast< bool >(val2);
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = (bool)(arg1)->MoveCursorUp(arg2);
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj = 0;
12332 wxGrid *arg1 = (wxGrid *) 0 ;
12333 bool arg2 ;
12334 bool result;
12335 void *argp1 = 0 ;
12336 int res1 = 0 ;
12337 bool val2 ;
12338 int ecode2 = 0 ;
12339 PyObject * obj0 = 0 ;
12340 PyObject * obj1 = 0 ;
12341 char * kwnames[] = {
12342 (char *) "self",(char *) "expandSelection", NULL
12343 };
12344
12345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12347 if (!SWIG_IsOK(res1)) {
12348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12349 }
12350 arg1 = reinterpret_cast< wxGrid * >(argp1);
12351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12352 if (!SWIG_IsOK(ecode2)) {
12353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12354 }
12355 arg2 = static_cast< bool >(val2);
12356 {
12357 PyThreadState* __tstate = wxPyBeginAllowThreads();
12358 result = (bool)(arg1)->MoveCursorDown(arg2);
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 {
12363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12364 }
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj = 0;
12373 wxGrid *arg1 = (wxGrid *) 0 ;
12374 bool arg2 ;
12375 bool result;
12376 void *argp1 = 0 ;
12377 int res1 = 0 ;
12378 bool val2 ;
12379 int ecode2 = 0 ;
12380 PyObject * obj0 = 0 ;
12381 PyObject * obj1 = 0 ;
12382 char * kwnames[] = {
12383 (char *) "self",(char *) "expandSelection", NULL
12384 };
12385
12386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12388 if (!SWIG_IsOK(res1)) {
12389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12390 }
12391 arg1 = reinterpret_cast< wxGrid * >(argp1);
12392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12393 if (!SWIG_IsOK(ecode2)) {
12394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12395 }
12396 arg2 = static_cast< bool >(val2);
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 result = (bool)(arg1)->MoveCursorLeft(arg2);
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 {
12404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12405 }
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj = 0;
12414 wxGrid *arg1 = (wxGrid *) 0 ;
12415 bool arg2 ;
12416 bool result;
12417 void *argp1 = 0 ;
12418 int res1 = 0 ;
12419 bool val2 ;
12420 int ecode2 = 0 ;
12421 PyObject * obj0 = 0 ;
12422 PyObject * obj1 = 0 ;
12423 char * kwnames[] = {
12424 (char *) "self",(char *) "expandSelection", NULL
12425 };
12426
12427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12429 if (!SWIG_IsOK(res1)) {
12430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12431 }
12432 arg1 = reinterpret_cast< wxGrid * >(argp1);
12433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12434 if (!SWIG_IsOK(ecode2)) {
12435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12436 }
12437 arg2 = static_cast< bool >(val2);
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (bool)(arg1)->MoveCursorRight(arg2);
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12446 }
12447 return resultobj;
12448 fail:
12449 return NULL;
12450 }
12451
12452
12453 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12454 PyObject *resultobj = 0;
12455 wxGrid *arg1 = (wxGrid *) 0 ;
12456 bool result;
12457 void *argp1 = 0 ;
12458 int res1 = 0 ;
12459 PyObject *swig_obj[1] ;
12460
12461 if (!args) SWIG_fail;
12462 swig_obj[0] = args;
12463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12464 if (!SWIG_IsOK(res1)) {
12465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12466 }
12467 arg1 = reinterpret_cast< wxGrid * >(argp1);
12468 {
12469 PyThreadState* __tstate = wxPyBeginAllowThreads();
12470 result = (bool)(arg1)->MovePageDown();
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 {
12475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12476 }
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12484 PyObject *resultobj = 0;
12485 wxGrid *arg1 = (wxGrid *) 0 ;
12486 bool result;
12487 void *argp1 = 0 ;
12488 int res1 = 0 ;
12489 PyObject *swig_obj[1] ;
12490
12491 if (!args) SWIG_fail;
12492 swig_obj[0] = args;
12493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12494 if (!SWIG_IsOK(res1)) {
12495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12496 }
12497 arg1 = reinterpret_cast< wxGrid * >(argp1);
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 result = (bool)(arg1)->MovePageUp();
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 {
12505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12506 }
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxGrid *arg1 = (wxGrid *) 0 ;
12516 bool arg2 ;
12517 bool result;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 bool val2 ;
12521 int ecode2 = 0 ;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12524 char * kwnames[] = {
12525 (char *) "self",(char *) "expandSelection", NULL
12526 };
12527
12528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12530 if (!SWIG_IsOK(res1)) {
12531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12532 }
12533 arg1 = reinterpret_cast< wxGrid * >(argp1);
12534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12535 if (!SWIG_IsOK(ecode2)) {
12536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12537 }
12538 arg2 = static_cast< bool >(val2);
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj = 0;
12556 wxGrid *arg1 = (wxGrid *) 0 ;
12557 bool arg2 ;
12558 bool result;
12559 void *argp1 = 0 ;
12560 int res1 = 0 ;
12561 bool val2 ;
12562 int ecode2 = 0 ;
12563 PyObject * obj0 = 0 ;
12564 PyObject * obj1 = 0 ;
12565 char * kwnames[] = {
12566 (char *) "self",(char *) "expandSelection", NULL
12567 };
12568
12569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12571 if (!SWIG_IsOK(res1)) {
12572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12573 }
12574 arg1 = reinterpret_cast< wxGrid * >(argp1);
12575 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12576 if (!SWIG_IsOK(ecode2)) {
12577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12578 }
12579 arg2 = static_cast< bool >(val2);
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 {
12587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12588 }
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj = 0;
12597 wxGrid *arg1 = (wxGrid *) 0 ;
12598 bool arg2 ;
12599 bool result;
12600 void *argp1 = 0 ;
12601 int res1 = 0 ;
12602 bool val2 ;
12603 int ecode2 = 0 ;
12604 PyObject * obj0 = 0 ;
12605 PyObject * obj1 = 0 ;
12606 char * kwnames[] = {
12607 (char *) "self",(char *) "expandSelection", NULL
12608 };
12609
12610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12614 }
12615 arg1 = reinterpret_cast< wxGrid * >(argp1);
12616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12617 if (!SWIG_IsOK(ecode2)) {
12618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12619 }
12620 arg2 = static_cast< bool >(val2);
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12629 }
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj = 0;
12638 wxGrid *arg1 = (wxGrid *) 0 ;
12639 bool arg2 ;
12640 bool result;
12641 void *argp1 = 0 ;
12642 int res1 = 0 ;
12643 bool val2 ;
12644 int ecode2 = 0 ;
12645 PyObject * obj0 = 0 ;
12646 PyObject * obj1 = 0 ;
12647 char * kwnames[] = {
12648 (char *) "self",(char *) "expandSelection", NULL
12649 };
12650
12651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12653 if (!SWIG_IsOK(res1)) {
12654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12655 }
12656 arg1 = reinterpret_cast< wxGrid * >(argp1);
12657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12658 if (!SWIG_IsOK(ecode2)) {
12659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12660 }
12661 arg2 = static_cast< bool >(val2);
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 {
12669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12670 }
12671 return resultobj;
12672 fail:
12673 return NULL;
12674 }
12675
12676
12677 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12678 PyObject *resultobj = 0;
12679 wxGrid *arg1 = (wxGrid *) 0 ;
12680 int result;
12681 void *argp1 = 0 ;
12682 int res1 = 0 ;
12683 PyObject *swig_obj[1] ;
12684
12685 if (!args) SWIG_fail;
12686 swig_obj[0] = args;
12687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12688 if (!SWIG_IsOK(res1)) {
12689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12690 }
12691 arg1 = reinterpret_cast< wxGrid * >(argp1);
12692 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 result = (int)(arg1)->GetDefaultRowLabelSize();
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 resultobj = SWIG_From_int(static_cast< int >(result));
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12706 PyObject *resultobj = 0;
12707 wxGrid *arg1 = (wxGrid *) 0 ;
12708 int result;
12709 void *argp1 = 0 ;
12710 int res1 = 0 ;
12711 PyObject *swig_obj[1] ;
12712
12713 if (!args) SWIG_fail;
12714 swig_obj[0] = args;
12715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12716 if (!SWIG_IsOK(res1)) {
12717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12718 }
12719 arg1 = reinterpret_cast< wxGrid * >(argp1);
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (int)(arg1)->GetRowLabelSize();
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 resultobj = SWIG_From_int(static_cast< int >(result));
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *resultobj = 0;
12735 wxGrid *arg1 = (wxGrid *) 0 ;
12736 int result;
12737 void *argp1 = 0 ;
12738 int res1 = 0 ;
12739 PyObject *swig_obj[1] ;
12740
12741 if (!args) SWIG_fail;
12742 swig_obj[0] = args;
12743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12744 if (!SWIG_IsOK(res1)) {
12745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12746 }
12747 arg1 = reinterpret_cast< wxGrid * >(argp1);
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (int)(arg1)->GetDefaultColLabelSize();
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 resultobj = SWIG_From_int(static_cast< int >(result));
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12762 PyObject *resultobj = 0;
12763 wxGrid *arg1 = (wxGrid *) 0 ;
12764 int result;
12765 void *argp1 = 0 ;
12766 int res1 = 0 ;
12767 PyObject *swig_obj[1] ;
12768
12769 if (!args) SWIG_fail;
12770 swig_obj[0] = args;
12771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12772 if (!SWIG_IsOK(res1)) {
12773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12774 }
12775 arg1 = reinterpret_cast< wxGrid * >(argp1);
12776 {
12777 PyThreadState* __tstate = wxPyBeginAllowThreads();
12778 result = (int)(arg1)->GetColLabelSize();
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 resultobj = SWIG_From_int(static_cast< int >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *resultobj = 0;
12791 wxGrid *arg1 = (wxGrid *) 0 ;
12792 wxColour result;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 PyObject *swig_obj[1] ;
12796
12797 if (!args) SWIG_fail;
12798 swig_obj[0] = args;
12799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12800 if (!SWIG_IsOK(res1)) {
12801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12802 }
12803 arg1 = reinterpret_cast< wxGrid * >(argp1);
12804 {
12805 PyThreadState* __tstate = wxPyBeginAllowThreads();
12806 result = (arg1)->GetLabelBackgroundColour();
12807 wxPyEndAllowThreads(__tstate);
12808 if (PyErr_Occurred()) SWIG_fail;
12809 }
12810 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12811 return resultobj;
12812 fail:
12813 return NULL;
12814 }
12815
12816
12817 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12818 PyObject *resultobj = 0;
12819 wxGrid *arg1 = (wxGrid *) 0 ;
12820 wxColour result;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 PyObject *swig_obj[1] ;
12824
12825 if (!args) SWIG_fail;
12826 swig_obj[0] = args;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12830 }
12831 arg1 = reinterpret_cast< wxGrid * >(argp1);
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 result = (arg1)->GetLabelTextColour();
12835 wxPyEndAllowThreads(__tstate);
12836 if (PyErr_Occurred()) SWIG_fail;
12837 }
12838 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12846 PyObject *resultobj = 0;
12847 wxGrid *arg1 = (wxGrid *) 0 ;
12848 wxFont result;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 PyObject *swig_obj[1] ;
12852
12853 if (!args) SWIG_fail;
12854 swig_obj[0] = args;
12855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12856 if (!SWIG_IsOK(res1)) {
12857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12858 }
12859 arg1 = reinterpret_cast< wxGrid * >(argp1);
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 result = (arg1)->GetLabelFont();
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874 PyObject *resultobj = 0;
12875 wxGrid *arg1 = (wxGrid *) 0 ;
12876 int *arg2 = (int *) 0 ;
12877 int *arg3 = (int *) 0 ;
12878 void *argp1 = 0 ;
12879 int res1 = 0 ;
12880 int temp2 ;
12881 int res2 = SWIG_TMPOBJ ;
12882 int temp3 ;
12883 int res3 = SWIG_TMPOBJ ;
12884 PyObject *swig_obj[1] ;
12885
12886 arg2 = &temp2;
12887 arg3 = &temp3;
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12893 }
12894 arg1 = reinterpret_cast< wxGrid * >(argp1);
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 (arg1)->GetRowLabelAlignment(arg2,arg3);
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 resultobj = SWIG_Py_Void();
12902 if (SWIG_IsTmpObj(res2)) {
12903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12904 } else {
12905 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12907 }
12908 if (SWIG_IsTmpObj(res3)) {
12909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12910 } else {
12911 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12913 }
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12921 PyObject *resultobj = 0;
12922 wxGrid *arg1 = (wxGrid *) 0 ;
12923 int *arg2 = (int *) 0 ;
12924 int *arg3 = (int *) 0 ;
12925 void *argp1 = 0 ;
12926 int res1 = 0 ;
12927 int temp2 ;
12928 int res2 = SWIG_TMPOBJ ;
12929 int temp3 ;
12930 int res3 = SWIG_TMPOBJ ;
12931 PyObject *swig_obj[1] ;
12932
12933 arg2 = &temp2;
12934 arg3 = &temp3;
12935 if (!args) SWIG_fail;
12936 swig_obj[0] = args;
12937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12938 if (!SWIG_IsOK(res1)) {
12939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12940 }
12941 arg1 = reinterpret_cast< wxGrid * >(argp1);
12942 {
12943 PyThreadState* __tstate = wxPyBeginAllowThreads();
12944 (arg1)->GetColLabelAlignment(arg2,arg3);
12945 wxPyEndAllowThreads(__tstate);
12946 if (PyErr_Occurred()) SWIG_fail;
12947 }
12948 resultobj = SWIG_Py_Void();
12949 if (SWIG_IsTmpObj(res2)) {
12950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12951 } else {
12952 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12954 }
12955 if (SWIG_IsTmpObj(res3)) {
12956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12957 } else {
12958 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12960 }
12961 return resultobj;
12962 fail:
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *resultobj = 0;
12969 wxGrid *arg1 = (wxGrid *) 0 ;
12970 int result;
12971 void *argp1 = 0 ;
12972 int res1 = 0 ;
12973 PyObject *swig_obj[1] ;
12974
12975 if (!args) SWIG_fail;
12976 swig_obj[0] = args;
12977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12978 if (!SWIG_IsOK(res1)) {
12979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12980 }
12981 arg1 = reinterpret_cast< wxGrid * >(argp1);
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (int)(arg1)->GetColLabelTextOrientation();
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 resultobj = SWIG_From_int(static_cast< int >(result));
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12996 PyObject *resultobj = 0;
12997 wxGrid *arg1 = (wxGrid *) 0 ;
12998 int arg2 ;
12999 wxString result;
13000 void *argp1 = 0 ;
13001 int res1 = 0 ;
13002 int val2 ;
13003 int ecode2 = 0 ;
13004 PyObject * obj0 = 0 ;
13005 PyObject * obj1 = 0 ;
13006 char * kwnames[] = {
13007 (char *) "self",(char *) "row", NULL
13008 };
13009
13010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13014 }
13015 arg1 = reinterpret_cast< wxGrid * >(argp1);
13016 ecode2 = SWIG_AsVal_int(obj1, &val2);
13017 if (!SWIG_IsOK(ecode2)) {
13018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13019 }
13020 arg2 = static_cast< int >(val2);
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 result = (arg1)->GetRowLabelValue(arg2);
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 {
13028 #if wxUSE_UNICODE
13029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13030 #else
13031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13032 #endif
13033 }
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj = 0;
13042 wxGrid *arg1 = (wxGrid *) 0 ;
13043 int arg2 ;
13044 wxString result;
13045 void *argp1 = 0 ;
13046 int res1 = 0 ;
13047 int val2 ;
13048 int ecode2 = 0 ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char * kwnames[] = {
13052 (char *) "self",(char *) "col", NULL
13053 };
13054
13055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13057 if (!SWIG_IsOK(res1)) {
13058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13059 }
13060 arg1 = reinterpret_cast< wxGrid * >(argp1);
13061 ecode2 = SWIG_AsVal_int(obj1, &val2);
13062 if (!SWIG_IsOK(ecode2)) {
13063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13064 }
13065 arg2 = static_cast< int >(val2);
13066 {
13067 PyThreadState* __tstate = wxPyBeginAllowThreads();
13068 result = (arg1)->GetColLabelValue(arg2);
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 {
13073 #if wxUSE_UNICODE
13074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13075 #else
13076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13077 #endif
13078 }
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13086 PyObject *resultobj = 0;
13087 wxGrid *arg1 = (wxGrid *) 0 ;
13088 wxColour result;
13089 void *argp1 = 0 ;
13090 int res1 = 0 ;
13091 PyObject *swig_obj[1] ;
13092
13093 if (!args) SWIG_fail;
13094 swig_obj[0] = args;
13095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13096 if (!SWIG_IsOK(res1)) {
13097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13098 }
13099 arg1 = reinterpret_cast< wxGrid * >(argp1);
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 result = (arg1)->GetGridLineColour();
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 wxGrid *arg1 = (wxGrid *) 0 ;
13116 wxColour result;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 PyObject *swig_obj[1] ;
13120
13121 if (!args) SWIG_fail;
13122 swig_obj[0] = args;
13123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13126 }
13127 arg1 = reinterpret_cast< wxGrid * >(argp1);
13128 {
13129 PyThreadState* __tstate = wxPyBeginAllowThreads();
13130 result = (arg1)->GetCellHighlightColour();
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142 PyObject *resultobj = 0;
13143 wxGrid *arg1 = (wxGrid *) 0 ;
13144 int result;
13145 void *argp1 = 0 ;
13146 int res1 = 0 ;
13147 PyObject *swig_obj[1] ;
13148
13149 if (!args) SWIG_fail;
13150 swig_obj[0] = args;
13151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13152 if (!SWIG_IsOK(res1)) {
13153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13154 }
13155 arg1 = reinterpret_cast< wxGrid * >(argp1);
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 result = (int)(arg1)->GetCellHighlightPenWidth();
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 resultobj = SWIG_From_int(static_cast< int >(result));
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13170 PyObject *resultobj = 0;
13171 wxGrid *arg1 = (wxGrid *) 0 ;
13172 int result;
13173 void *argp1 = 0 ;
13174 int res1 = 0 ;
13175 PyObject *swig_obj[1] ;
13176
13177 if (!args) SWIG_fail;
13178 swig_obj[0] = args;
13179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13180 if (!SWIG_IsOK(res1)) {
13181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13182 }
13183 arg1 = reinterpret_cast< wxGrid * >(argp1);
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (int)(arg1)->GetCellHighlightROPenWidth();
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 resultobj = SWIG_From_int(static_cast< int >(result));
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj = 0;
13199 wxGrid *arg1 = (wxGrid *) 0 ;
13200 int arg2 ;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 int val2 ;
13204 int ecode2 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 char * kwnames[] = {
13208 (char *) "self",(char *) "width", NULL
13209 };
13210
13211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13213 if (!SWIG_IsOK(res1)) {
13214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13215 }
13216 arg1 = reinterpret_cast< wxGrid * >(argp1);
13217 ecode2 = SWIG_AsVal_int(obj1, &val2);
13218 if (!SWIG_IsOK(ecode2)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13220 }
13221 arg2 = static_cast< int >(val2);
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 (arg1)->SetRowLabelSize(arg2);
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 resultobj = SWIG_Py_Void();
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj = 0;
13237 wxGrid *arg1 = (wxGrid *) 0 ;
13238 int arg2 ;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 int val2 ;
13242 int ecode2 = 0 ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245 char * kwnames[] = {
13246 (char *) "self",(char *) "height", NULL
13247 };
13248
13249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13251 if (!SWIG_IsOK(res1)) {
13252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13253 }
13254 arg1 = reinterpret_cast< wxGrid * >(argp1);
13255 ecode2 = SWIG_AsVal_int(obj1, &val2);
13256 if (!SWIG_IsOK(ecode2)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13258 }
13259 arg2 = static_cast< int >(val2);
13260 {
13261 PyThreadState* __tstate = wxPyBeginAllowThreads();
13262 (arg1)->SetColLabelSize(arg2);
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 resultobj = SWIG_Py_Void();
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj = 0;
13275 wxGrid *arg1 = (wxGrid *) 0 ;
13276 wxColour *arg2 = 0 ;
13277 void *argp1 = 0 ;
13278 int res1 = 0 ;
13279 wxColour temp2 ;
13280 PyObject * obj0 = 0 ;
13281 PyObject * obj1 = 0 ;
13282 char * kwnames[] = {
13283 (char *) "self",(char *)"arg2", NULL
13284 };
13285
13286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13290 }
13291 arg1 = reinterpret_cast< wxGrid * >(argp1);
13292 {
13293 arg2 = &temp2;
13294 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13299 wxPyEndAllowThreads(__tstate);
13300 if (PyErr_Occurred()) SWIG_fail;
13301 }
13302 resultobj = SWIG_Py_Void();
13303 return resultobj;
13304 fail:
13305 return NULL;
13306 }
13307
13308
13309 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13310 PyObject *resultobj = 0;
13311 wxGrid *arg1 = (wxGrid *) 0 ;
13312 wxColour *arg2 = 0 ;
13313 void *argp1 = 0 ;
13314 int res1 = 0 ;
13315 wxColour temp2 ;
13316 PyObject * obj0 = 0 ;
13317 PyObject * obj1 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "self",(char *)"arg2", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13326 }
13327 arg1 = reinterpret_cast< wxGrid * >(argp1);
13328 {
13329 arg2 = &temp2;
13330 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13331 }
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_Py_Void();
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj = 0;
13347 wxGrid *arg1 = (wxGrid *) 0 ;
13348 wxFont *arg2 = 0 ;
13349 void *argp1 = 0 ;
13350 int res1 = 0 ;
13351 void *argp2 = 0 ;
13352 int res2 = 0 ;
13353 PyObject * obj0 = 0 ;
13354 PyObject * obj1 = 0 ;
13355 char * kwnames[] = {
13356 (char *) "self",(char *)"arg2", NULL
13357 };
13358
13359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13361 if (!SWIG_IsOK(res1)) {
13362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13363 }
13364 arg1 = reinterpret_cast< wxGrid * >(argp1);
13365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13366 if (!SWIG_IsOK(res2)) {
13367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13368 }
13369 if (!argp2) {
13370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13371 }
13372 arg2 = reinterpret_cast< wxFont * >(argp2);
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 (arg1)->SetLabelFont((wxFont const &)*arg2);
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = SWIG_Py_Void();
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13387 PyObject *resultobj = 0;
13388 wxGrid *arg1 = (wxGrid *) 0 ;
13389 int arg2 ;
13390 int arg3 ;
13391 void *argp1 = 0 ;
13392 int res1 = 0 ;
13393 int val2 ;
13394 int ecode2 = 0 ;
13395 int val3 ;
13396 int ecode3 = 0 ;
13397 PyObject * obj0 = 0 ;
13398 PyObject * obj1 = 0 ;
13399 PyObject * obj2 = 0 ;
13400 char * kwnames[] = {
13401 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13402 };
13403
13404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13406 if (!SWIG_IsOK(res1)) {
13407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13408 }
13409 arg1 = reinterpret_cast< wxGrid * >(argp1);
13410 ecode2 = SWIG_AsVal_int(obj1, &val2);
13411 if (!SWIG_IsOK(ecode2)) {
13412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13413 }
13414 arg2 = static_cast< int >(val2);
13415 ecode3 = SWIG_AsVal_int(obj2, &val3);
13416 if (!SWIG_IsOK(ecode3)) {
13417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13418 }
13419 arg3 = static_cast< int >(val3);
13420 {
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 (arg1)->SetRowLabelAlignment(arg2,arg3);
13423 wxPyEndAllowThreads(__tstate);
13424 if (PyErr_Occurred()) SWIG_fail;
13425 }
13426 resultobj = SWIG_Py_Void();
13427 return resultobj;
13428 fail:
13429 return NULL;
13430 }
13431
13432
13433 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13434 PyObject *resultobj = 0;
13435 wxGrid *arg1 = (wxGrid *) 0 ;
13436 int arg2 ;
13437 int arg3 ;
13438 void *argp1 = 0 ;
13439 int res1 = 0 ;
13440 int val2 ;
13441 int ecode2 = 0 ;
13442 int val3 ;
13443 int ecode3 = 0 ;
13444 PyObject * obj0 = 0 ;
13445 PyObject * obj1 = 0 ;
13446 PyObject * obj2 = 0 ;
13447 char * kwnames[] = {
13448 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13449 };
13450
13451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13453 if (!SWIG_IsOK(res1)) {
13454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13455 }
13456 arg1 = reinterpret_cast< wxGrid * >(argp1);
13457 ecode2 = SWIG_AsVal_int(obj1, &val2);
13458 if (!SWIG_IsOK(ecode2)) {
13459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13460 }
13461 arg2 = static_cast< int >(val2);
13462 ecode3 = SWIG_AsVal_int(obj2, &val3);
13463 if (!SWIG_IsOK(ecode3)) {
13464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13465 }
13466 arg3 = static_cast< int >(val3);
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 (arg1)->SetColLabelAlignment(arg2,arg3);
13470 wxPyEndAllowThreads(__tstate);
13471 if (PyErr_Occurred()) SWIG_fail;
13472 }
13473 resultobj = SWIG_Py_Void();
13474 return resultobj;
13475 fail:
13476 return NULL;
13477 }
13478
13479
13480 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj = 0;
13482 wxGrid *arg1 = (wxGrid *) 0 ;
13483 int arg2 ;
13484 void *argp1 = 0 ;
13485 int res1 = 0 ;
13486 int val2 ;
13487 int ecode2 = 0 ;
13488 PyObject * obj0 = 0 ;
13489 PyObject * obj1 = 0 ;
13490 char * kwnames[] = {
13491 (char *) "self",(char *) "textOrientation", NULL
13492 };
13493
13494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13496 if (!SWIG_IsOK(res1)) {
13497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13498 }
13499 arg1 = reinterpret_cast< wxGrid * >(argp1);
13500 ecode2 = SWIG_AsVal_int(obj1, &val2);
13501 if (!SWIG_IsOK(ecode2)) {
13502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13503 }
13504 arg2 = static_cast< int >(val2);
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 (arg1)->SetColLabelTextOrientation(arg2);
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 resultobj = SWIG_Py_Void();
13512 return resultobj;
13513 fail:
13514 return NULL;
13515 }
13516
13517
13518 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13519 PyObject *resultobj = 0;
13520 wxGrid *arg1 = (wxGrid *) 0 ;
13521 int arg2 ;
13522 wxString *arg3 = 0 ;
13523 void *argp1 = 0 ;
13524 int res1 = 0 ;
13525 int val2 ;
13526 int ecode2 = 0 ;
13527 bool temp3 = false ;
13528 PyObject * obj0 = 0 ;
13529 PyObject * obj1 = 0 ;
13530 PyObject * obj2 = 0 ;
13531 char * kwnames[] = {
13532 (char *) "self",(char *) "row",(char *)"arg3", NULL
13533 };
13534
13535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13537 if (!SWIG_IsOK(res1)) {
13538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13539 }
13540 arg1 = reinterpret_cast< wxGrid * >(argp1);
13541 ecode2 = SWIG_AsVal_int(obj1, &val2);
13542 if (!SWIG_IsOK(ecode2)) {
13543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13544 }
13545 arg2 = static_cast< int >(val2);
13546 {
13547 arg3 = wxString_in_helper(obj2);
13548 if (arg3 == NULL) SWIG_fail;
13549 temp3 = true;
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_Py_Void();
13558 {
13559 if (temp3)
13560 delete arg3;
13561 }
13562 return resultobj;
13563 fail:
13564 {
13565 if (temp3)
13566 delete arg3;
13567 }
13568 return NULL;
13569 }
13570
13571
13572 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj = 0;
13574 wxGrid *arg1 = (wxGrid *) 0 ;
13575 int arg2 ;
13576 wxString *arg3 = 0 ;
13577 void *argp1 = 0 ;
13578 int res1 = 0 ;
13579 int val2 ;
13580 int ecode2 = 0 ;
13581 bool temp3 = false ;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 PyObject * obj2 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "self",(char *) "col",(char *)"arg3", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13593 }
13594 arg1 = reinterpret_cast< wxGrid * >(argp1);
13595 ecode2 = SWIG_AsVal_int(obj1, &val2);
13596 if (!SWIG_IsOK(ecode2)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13598 }
13599 arg2 = static_cast< int >(val2);
13600 {
13601 arg3 = wxString_in_helper(obj2);
13602 if (arg3 == NULL) SWIG_fail;
13603 temp3 = true;
13604 }
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13608 wxPyEndAllowThreads(__tstate);
13609 if (PyErr_Occurred()) SWIG_fail;
13610 }
13611 resultobj = SWIG_Py_Void();
13612 {
13613 if (temp3)
13614 delete arg3;
13615 }
13616 return resultobj;
13617 fail:
13618 {
13619 if (temp3)
13620 delete arg3;
13621 }
13622 return NULL;
13623 }
13624
13625
13626 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj = 0;
13628 wxGrid *arg1 = (wxGrid *) 0 ;
13629 wxColour *arg2 = 0 ;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 wxColour temp2 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 char * kwnames[] = {
13636 (char *) "self",(char *)"arg2", NULL
13637 };
13638
13639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13641 if (!SWIG_IsOK(res1)) {
13642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13643 }
13644 arg1 = reinterpret_cast< wxGrid * >(argp1);
13645 {
13646 arg2 = &temp2;
13647 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13648 }
13649 {
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 resultobj = SWIG_Py_Void();
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj = 0;
13664 wxGrid *arg1 = (wxGrid *) 0 ;
13665 wxColour *arg2 = 0 ;
13666 void *argp1 = 0 ;
13667 int res1 = 0 ;
13668 wxColour temp2 ;
13669 PyObject * obj0 = 0 ;
13670 PyObject * obj1 = 0 ;
13671 char * kwnames[] = {
13672 (char *) "self",(char *)"arg2", NULL
13673 };
13674
13675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13677 if (!SWIG_IsOK(res1)) {
13678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13679 }
13680 arg1 = reinterpret_cast< wxGrid * >(argp1);
13681 {
13682 arg2 = &temp2;
13683 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13684 }
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 resultobj = SWIG_Py_Void();
13692 return resultobj;
13693 fail:
13694 return NULL;
13695 }
13696
13697
13698 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj = 0;
13700 wxGrid *arg1 = (wxGrid *) 0 ;
13701 int arg2 ;
13702 void *argp1 = 0 ;
13703 int res1 = 0 ;
13704 int val2 ;
13705 int ecode2 = 0 ;
13706 PyObject * obj0 = 0 ;
13707 PyObject * obj1 = 0 ;
13708 char * kwnames[] = {
13709 (char *) "self",(char *) "width", NULL
13710 };
13711
13712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13714 if (!SWIG_IsOK(res1)) {
13715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13716 }
13717 arg1 = reinterpret_cast< wxGrid * >(argp1);
13718 ecode2 = SWIG_AsVal_int(obj1, &val2);
13719 if (!SWIG_IsOK(ecode2)) {
13720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13721 }
13722 arg2 = static_cast< int >(val2);
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 (arg1)->SetCellHighlightPenWidth(arg2);
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 resultobj = SWIG_Py_Void();
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj = 0;
13738 wxGrid *arg1 = (wxGrid *) 0 ;
13739 int arg2 ;
13740 void *argp1 = 0 ;
13741 int res1 = 0 ;
13742 int val2 ;
13743 int ecode2 = 0 ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 char * kwnames[] = {
13747 (char *) "self",(char *) "width", NULL
13748 };
13749
13750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13752 if (!SWIG_IsOK(res1)) {
13753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13754 }
13755 arg1 = reinterpret_cast< wxGrid * >(argp1);
13756 ecode2 = SWIG_AsVal_int(obj1, &val2);
13757 if (!SWIG_IsOK(ecode2)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13759 }
13760 arg2 = static_cast< int >(val2);
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 (arg1)->SetCellHighlightROPenWidth(arg2);
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 resultobj = SWIG_Py_Void();
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj = 0;
13776 wxGrid *arg1 = (wxGrid *) 0 ;
13777 bool arg2 = (bool) true ;
13778 void *argp1 = 0 ;
13779 int res1 = 0 ;
13780 bool val2 ;
13781 int ecode2 = 0 ;
13782 PyObject * obj0 = 0 ;
13783 PyObject * obj1 = 0 ;
13784 char * kwnames[] = {
13785 (char *) "self",(char *) "enable", NULL
13786 };
13787
13788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13790 if (!SWIG_IsOK(res1)) {
13791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13792 }
13793 arg1 = reinterpret_cast< wxGrid * >(argp1);
13794 if (obj1) {
13795 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13796 if (!SWIG_IsOK(ecode2)) {
13797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13798 }
13799 arg2 = static_cast< bool >(val2);
13800 }
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 (arg1)->EnableDragRowSize(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_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13815 PyObject *resultobj = 0;
13816 wxGrid *arg1 = (wxGrid *) 0 ;
13817 void *argp1 = 0 ;
13818 int res1 = 0 ;
13819 PyObject *swig_obj[1] ;
13820
13821 if (!args) SWIG_fail;
13822 swig_obj[0] = args;
13823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13824 if (!SWIG_IsOK(res1)) {
13825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13826 }
13827 arg1 = reinterpret_cast< wxGrid * >(argp1);
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 (arg1)->DisableDragRowSize();
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 resultobj = SWIG_Py_Void();
13835 return resultobj;
13836 fail:
13837 return NULL;
13838 }
13839
13840
13841 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13842 PyObject *resultobj = 0;
13843 wxGrid *arg1 = (wxGrid *) 0 ;
13844 bool result;
13845 void *argp1 = 0 ;
13846 int res1 = 0 ;
13847 PyObject *swig_obj[1] ;
13848
13849 if (!args) SWIG_fail;
13850 swig_obj[0] = args;
13851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13852 if (!SWIG_IsOK(res1)) {
13853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13854 }
13855 arg1 = reinterpret_cast< wxGrid * >(argp1);
13856 {
13857 PyThreadState* __tstate = wxPyBeginAllowThreads();
13858 result = (bool)(arg1)->CanDragRowSize();
13859 wxPyEndAllowThreads(__tstate);
13860 if (PyErr_Occurred()) SWIG_fail;
13861 }
13862 {
13863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13864 }
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13872 PyObject *resultobj = 0;
13873 wxGrid *arg1 = (wxGrid *) 0 ;
13874 bool arg2 = (bool) true ;
13875 void *argp1 = 0 ;
13876 int res1 = 0 ;
13877 bool val2 ;
13878 int ecode2 = 0 ;
13879 PyObject * obj0 = 0 ;
13880 PyObject * obj1 = 0 ;
13881 char * kwnames[] = {
13882 (char *) "self",(char *) "enable", NULL
13883 };
13884
13885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13887 if (!SWIG_IsOK(res1)) {
13888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13889 }
13890 arg1 = reinterpret_cast< wxGrid * >(argp1);
13891 if (obj1) {
13892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13893 if (!SWIG_IsOK(ecode2)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13895 }
13896 arg2 = static_cast< bool >(val2);
13897 }
13898 {
13899 PyThreadState* __tstate = wxPyBeginAllowThreads();
13900 (arg1)->EnableDragColSize(arg2);
13901 wxPyEndAllowThreads(__tstate);
13902 if (PyErr_Occurred()) SWIG_fail;
13903 }
13904 resultobj = SWIG_Py_Void();
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13912 PyObject *resultobj = 0;
13913 wxGrid *arg1 = (wxGrid *) 0 ;
13914 void *argp1 = 0 ;
13915 int res1 = 0 ;
13916 PyObject *swig_obj[1] ;
13917
13918 if (!args) SWIG_fail;
13919 swig_obj[0] = args;
13920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13921 if (!SWIG_IsOK(res1)) {
13922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13923 }
13924 arg1 = reinterpret_cast< wxGrid * >(argp1);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 (arg1)->DisableDragColSize();
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_Py_Void();
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13939 PyObject *resultobj = 0;
13940 wxGrid *arg1 = (wxGrid *) 0 ;
13941 bool result;
13942 void *argp1 = 0 ;
13943 int res1 = 0 ;
13944 PyObject *swig_obj[1] ;
13945
13946 if (!args) SWIG_fail;
13947 swig_obj[0] = args;
13948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13949 if (!SWIG_IsOK(res1)) {
13950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13951 }
13952 arg1 = reinterpret_cast< wxGrid * >(argp1);
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 result = (bool)(arg1)->CanDragColSize();
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 {
13960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13961 }
13962 return resultobj;
13963 fail:
13964 return NULL;
13965 }
13966
13967
13968 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj = 0;
13970 wxGrid *arg1 = (wxGrid *) 0 ;
13971 bool arg2 = (bool) true ;
13972 void *argp1 = 0 ;
13973 int res1 = 0 ;
13974 bool val2 ;
13975 int ecode2 = 0 ;
13976 PyObject * obj0 = 0 ;
13977 PyObject * obj1 = 0 ;
13978 char * kwnames[] = {
13979 (char *) "self",(char *) "enable", NULL
13980 };
13981
13982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
13983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13984 if (!SWIG_IsOK(res1)) {
13985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
13986 }
13987 arg1 = reinterpret_cast< wxGrid * >(argp1);
13988 if (obj1) {
13989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13990 if (!SWIG_IsOK(ecode2)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
13992 }
13993 arg2 = static_cast< bool >(val2);
13994 }
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 (arg1)->EnableDragColMove(arg2);
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_Py_Void();
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14009 PyObject *resultobj = 0;
14010 wxGrid *arg1 = (wxGrid *) 0 ;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 PyObject *swig_obj[1] ;
14014
14015 if (!args) SWIG_fail;
14016 swig_obj[0] = args;
14017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14020 }
14021 arg1 = reinterpret_cast< wxGrid * >(argp1);
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 (arg1)->DisableDragColMove();
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 resultobj = SWIG_Py_Void();
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14036 PyObject *resultobj = 0;
14037 wxGrid *arg1 = (wxGrid *) 0 ;
14038 bool result;
14039 void *argp1 = 0 ;
14040 int res1 = 0 ;
14041 PyObject *swig_obj[1] ;
14042
14043 if (!args) SWIG_fail;
14044 swig_obj[0] = args;
14045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14046 if (!SWIG_IsOK(res1)) {
14047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14048 }
14049 arg1 = reinterpret_cast< wxGrid * >(argp1);
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 result = (bool)(arg1)->CanDragColMove();
14053 wxPyEndAllowThreads(__tstate);
14054 if (PyErr_Occurred()) SWIG_fail;
14055 }
14056 {
14057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14058 }
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj = 0;
14067 wxGrid *arg1 = (wxGrid *) 0 ;
14068 bool arg2 = (bool) true ;
14069 void *argp1 = 0 ;
14070 int res1 = 0 ;
14071 bool val2 ;
14072 int ecode2 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 char * kwnames[] = {
14076 (char *) "self",(char *) "enable", NULL
14077 };
14078
14079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14083 }
14084 arg1 = reinterpret_cast< wxGrid * >(argp1);
14085 if (obj1) {
14086 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14087 if (!SWIG_IsOK(ecode2)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14089 }
14090 arg2 = static_cast< bool >(val2);
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 (arg1)->EnableDragGridSize(arg2);
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 resultobj = SWIG_Py_Void();
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14106 PyObject *resultobj = 0;
14107 wxGrid *arg1 = (wxGrid *) 0 ;
14108 void *argp1 = 0 ;
14109 int res1 = 0 ;
14110 PyObject *swig_obj[1] ;
14111
14112 if (!args) SWIG_fail;
14113 swig_obj[0] = args;
14114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14115 if (!SWIG_IsOK(res1)) {
14116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14117 }
14118 arg1 = reinterpret_cast< wxGrid * >(argp1);
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 (arg1)->DisableDragGridSize();
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 resultobj = SWIG_Py_Void();
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14133 PyObject *resultobj = 0;
14134 wxGrid *arg1 = (wxGrid *) 0 ;
14135 bool result;
14136 void *argp1 = 0 ;
14137 int res1 = 0 ;
14138 PyObject *swig_obj[1] ;
14139
14140 if (!args) SWIG_fail;
14141 swig_obj[0] = args;
14142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14143 if (!SWIG_IsOK(res1)) {
14144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14145 }
14146 arg1 = reinterpret_cast< wxGrid * >(argp1);
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 result = (bool)(arg1)->CanDragGridSize();
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 {
14154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14155 }
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14163 PyObject *resultobj = 0;
14164 wxGrid *arg1 = (wxGrid *) 0 ;
14165 bool arg2 = (bool) true ;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 bool val2 ;
14169 int ecode2 = 0 ;
14170 PyObject * obj0 = 0 ;
14171 PyObject * obj1 = 0 ;
14172 char * kwnames[] = {
14173 (char *) "self",(char *) "enable", NULL
14174 };
14175
14176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14180 }
14181 arg1 = reinterpret_cast< wxGrid * >(argp1);
14182 if (obj1) {
14183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14184 if (!SWIG_IsOK(ecode2)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14186 }
14187 arg2 = static_cast< bool >(val2);
14188 }
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 (arg1)->EnableDragCell(arg2);
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = SWIG_Py_Void();
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14203 PyObject *resultobj = 0;
14204 wxGrid *arg1 = (wxGrid *) 0 ;
14205 void *argp1 = 0 ;
14206 int res1 = 0 ;
14207 PyObject *swig_obj[1] ;
14208
14209 if (!args) SWIG_fail;
14210 swig_obj[0] = args;
14211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14212 if (!SWIG_IsOK(res1)) {
14213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14214 }
14215 arg1 = reinterpret_cast< wxGrid * >(argp1);
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 (arg1)->DisableDragCell();
14219 wxPyEndAllowThreads(__tstate);
14220 if (PyErr_Occurred()) SWIG_fail;
14221 }
14222 resultobj = SWIG_Py_Void();
14223 return resultobj;
14224 fail:
14225 return NULL;
14226 }
14227
14228
14229 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14230 PyObject *resultobj = 0;
14231 wxGrid *arg1 = (wxGrid *) 0 ;
14232 bool result;
14233 void *argp1 = 0 ;
14234 int res1 = 0 ;
14235 PyObject *swig_obj[1] ;
14236
14237 if (!args) SWIG_fail;
14238 swig_obj[0] = args;
14239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14242 }
14243 arg1 = reinterpret_cast< wxGrid * >(argp1);
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 result = (bool)(arg1)->CanDragCell();
14247 wxPyEndAllowThreads(__tstate);
14248 if (PyErr_Occurred()) SWIG_fail;
14249 }
14250 {
14251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14252 }
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj = 0;
14261 wxGrid *arg1 = (wxGrid *) 0 ;
14262 int arg2 ;
14263 int arg3 ;
14264 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 int val2 ;
14268 int ecode2 = 0 ;
14269 int val3 ;
14270 int ecode3 = 0 ;
14271 void *argp4 = 0 ;
14272 int res4 = 0 ;
14273 PyObject * obj0 = 0 ;
14274 PyObject * obj1 = 0 ;
14275 PyObject * obj2 = 0 ;
14276 PyObject * obj3 = 0 ;
14277 char * kwnames[] = {
14278 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14279 };
14280
14281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14285 }
14286 arg1 = reinterpret_cast< wxGrid * >(argp1);
14287 ecode2 = SWIG_AsVal_int(obj1, &val2);
14288 if (!SWIG_IsOK(ecode2)) {
14289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14290 }
14291 arg2 = static_cast< int >(val2);
14292 ecode3 = SWIG_AsVal_int(obj2, &val3);
14293 if (!SWIG_IsOK(ecode3)) {
14294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14295 }
14296 arg3 = static_cast< int >(val3);
14297 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14298 if (!SWIG_IsOK(res4)) {
14299 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14300 }
14301 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 (arg1)->SetAttr(arg2,arg3,arg4);
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 resultobj = SWIG_Py_Void();
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj = 0;
14317 wxGrid *arg1 = (wxGrid *) 0 ;
14318 int arg2 ;
14319 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14320 void *argp1 = 0 ;
14321 int res1 = 0 ;
14322 int val2 ;
14323 int ecode2 = 0 ;
14324 void *argp3 = 0 ;
14325 int res3 = 0 ;
14326 PyObject * obj0 = 0 ;
14327 PyObject * obj1 = 0 ;
14328 PyObject * obj2 = 0 ;
14329 char * kwnames[] = {
14330 (char *) "self",(char *) "row",(char *) "attr", NULL
14331 };
14332
14333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14335 if (!SWIG_IsOK(res1)) {
14336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14337 }
14338 arg1 = reinterpret_cast< wxGrid * >(argp1);
14339 ecode2 = SWIG_AsVal_int(obj1, &val2);
14340 if (!SWIG_IsOK(ecode2)) {
14341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14342 }
14343 arg2 = static_cast< int >(val2);
14344 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14345 if (!SWIG_IsOK(res3)) {
14346 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14347 }
14348 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 (arg1)->SetRowAttr(arg2,arg3);
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 resultobj = SWIG_Py_Void();
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj = 0;
14364 wxGrid *arg1 = (wxGrid *) 0 ;
14365 int arg2 ;
14366 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14367 void *argp1 = 0 ;
14368 int res1 = 0 ;
14369 int val2 ;
14370 int ecode2 = 0 ;
14371 void *argp3 = 0 ;
14372 int res3 = 0 ;
14373 PyObject * obj0 = 0 ;
14374 PyObject * obj1 = 0 ;
14375 PyObject * obj2 = 0 ;
14376 char * kwnames[] = {
14377 (char *) "self",(char *) "col",(char *) "attr", NULL
14378 };
14379
14380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14382 if (!SWIG_IsOK(res1)) {
14383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14384 }
14385 arg1 = reinterpret_cast< wxGrid * >(argp1);
14386 ecode2 = SWIG_AsVal_int(obj1, &val2);
14387 if (!SWIG_IsOK(ecode2)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14389 }
14390 arg2 = static_cast< int >(val2);
14391 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14392 if (!SWIG_IsOK(res3)) {
14393 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14394 }
14395 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 (arg1)->SetColAttr(arg2,arg3);
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_Py_Void();
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj = 0;
14411 wxGrid *arg1 = (wxGrid *) 0 ;
14412 int arg2 ;
14413 int arg3 ;
14414 wxGridCellAttr *result = 0 ;
14415 void *argp1 = 0 ;
14416 int res1 = 0 ;
14417 int val2 ;
14418 int ecode2 = 0 ;
14419 int val3 ;
14420 int ecode3 = 0 ;
14421 PyObject * obj0 = 0 ;
14422 PyObject * obj1 = 0 ;
14423 PyObject * obj2 = 0 ;
14424 char * kwnames[] = {
14425 (char *) "self",(char *) "row",(char *) "col", NULL
14426 };
14427
14428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14430 if (!SWIG_IsOK(res1)) {
14431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14432 }
14433 arg1 = reinterpret_cast< wxGrid * >(argp1);
14434 ecode2 = SWIG_AsVal_int(obj1, &val2);
14435 if (!SWIG_IsOK(ecode2)) {
14436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14437 }
14438 arg2 = static_cast< int >(val2);
14439 ecode3 = SWIG_AsVal_int(obj2, &val3);
14440 if (!SWIG_IsOK(ecode3)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14442 }
14443 arg3 = static_cast< int >(val3);
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 {
14451 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxGrid *arg1 = (wxGrid *) 0 ;
14462 int arg2 ;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 int val2 ;
14466 int ecode2 = 0 ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char * kwnames[] = {
14470 (char *) "self",(char *) "col", NULL
14471 };
14472
14473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14475 if (!SWIG_IsOK(res1)) {
14476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14477 }
14478 arg1 = reinterpret_cast< wxGrid * >(argp1);
14479 ecode2 = SWIG_AsVal_int(obj1, &val2);
14480 if (!SWIG_IsOK(ecode2)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14482 }
14483 arg2 = static_cast< int >(val2);
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 (arg1)->SetColFormatBool(arg2);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = SWIG_Py_Void();
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxGrid *arg1 = (wxGrid *) 0 ;
14500 int arg2 ;
14501 void *argp1 = 0 ;
14502 int res1 = 0 ;
14503 int val2 ;
14504 int ecode2 = 0 ;
14505 PyObject * obj0 = 0 ;
14506 PyObject * obj1 = 0 ;
14507 char * kwnames[] = {
14508 (char *) "self",(char *) "col", NULL
14509 };
14510
14511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14515 }
14516 arg1 = reinterpret_cast< wxGrid * >(argp1);
14517 ecode2 = SWIG_AsVal_int(obj1, &val2);
14518 if (!SWIG_IsOK(ecode2)) {
14519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14520 }
14521 arg2 = static_cast< int >(val2);
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 (arg1)->SetColFormatNumber(arg2);
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = SWIG_Py_Void();
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj = 0;
14537 wxGrid *arg1 = (wxGrid *) 0 ;
14538 int arg2 ;
14539 int arg3 = (int) -1 ;
14540 int arg4 = (int) -1 ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 int val2 ;
14544 int ecode2 = 0 ;
14545 int val3 ;
14546 int ecode3 = 0 ;
14547 int val4 ;
14548 int ecode4 = 0 ;
14549 PyObject * obj0 = 0 ;
14550 PyObject * obj1 = 0 ;
14551 PyObject * obj2 = 0 ;
14552 PyObject * obj3 = 0 ;
14553 char * kwnames[] = {
14554 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14555 };
14556
14557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14559 if (!SWIG_IsOK(res1)) {
14560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14561 }
14562 arg1 = reinterpret_cast< wxGrid * >(argp1);
14563 ecode2 = SWIG_AsVal_int(obj1, &val2);
14564 if (!SWIG_IsOK(ecode2)) {
14565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14566 }
14567 arg2 = static_cast< int >(val2);
14568 if (obj2) {
14569 ecode3 = SWIG_AsVal_int(obj2, &val3);
14570 if (!SWIG_IsOK(ecode3)) {
14571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14572 }
14573 arg3 = static_cast< int >(val3);
14574 }
14575 if (obj3) {
14576 ecode4 = SWIG_AsVal_int(obj3, &val4);
14577 if (!SWIG_IsOK(ecode4)) {
14578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14579 }
14580 arg4 = static_cast< int >(val4);
14581 }
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 resultobj = SWIG_Py_Void();
14589 return resultobj;
14590 fail:
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14596 PyObject *resultobj = 0;
14597 wxGrid *arg1 = (wxGrid *) 0 ;
14598 int arg2 ;
14599 wxString *arg3 = 0 ;
14600 void *argp1 = 0 ;
14601 int res1 = 0 ;
14602 int val2 ;
14603 int ecode2 = 0 ;
14604 bool temp3 = false ;
14605 PyObject * obj0 = 0 ;
14606 PyObject * obj1 = 0 ;
14607 PyObject * obj2 = 0 ;
14608 char * kwnames[] = {
14609 (char *) "self",(char *) "col",(char *) "typeName", NULL
14610 };
14611
14612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14616 }
14617 arg1 = reinterpret_cast< wxGrid * >(argp1);
14618 ecode2 = SWIG_AsVal_int(obj1, &val2);
14619 if (!SWIG_IsOK(ecode2)) {
14620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14621 }
14622 arg2 = static_cast< int >(val2);
14623 {
14624 arg3 = wxString_in_helper(obj2);
14625 if (arg3 == NULL) SWIG_fail;
14626 temp3 = true;
14627 }
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 {
14636 if (temp3)
14637 delete arg3;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp3)
14643 delete arg3;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj = 0;
14651 wxGrid *arg1 = (wxGrid *) 0 ;
14652 bool arg2 = (bool) true ;
14653 void *argp1 = 0 ;
14654 int res1 = 0 ;
14655 bool val2 ;
14656 int ecode2 = 0 ;
14657 PyObject * obj0 = 0 ;
14658 PyObject * obj1 = 0 ;
14659 char * kwnames[] = {
14660 (char *) "self",(char *) "enable", NULL
14661 };
14662
14663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14665 if (!SWIG_IsOK(res1)) {
14666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14667 }
14668 arg1 = reinterpret_cast< wxGrid * >(argp1);
14669 if (obj1) {
14670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14671 if (!SWIG_IsOK(ecode2)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14673 }
14674 arg2 = static_cast< bool >(val2);
14675 }
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 (arg1)->EnableGridLines(arg2);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = SWIG_Py_Void();
14683 return resultobj;
14684 fail:
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14690 PyObject *resultobj = 0;
14691 wxGrid *arg1 = (wxGrid *) 0 ;
14692 bool result;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 PyObject *swig_obj[1] ;
14696
14697 if (!args) SWIG_fail;
14698 swig_obj[0] = args;
14699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14700 if (!SWIG_IsOK(res1)) {
14701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14702 }
14703 arg1 = reinterpret_cast< wxGrid * >(argp1);
14704 {
14705 PyThreadState* __tstate = wxPyBeginAllowThreads();
14706 result = (bool)(arg1)->GridLinesEnabled();
14707 wxPyEndAllowThreads(__tstate);
14708 if (PyErr_Occurred()) SWIG_fail;
14709 }
14710 {
14711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14712 }
14713 return resultobj;
14714 fail:
14715 return NULL;
14716 }
14717
14718
14719 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14720 PyObject *resultobj = 0;
14721 wxGrid *arg1 = (wxGrid *) 0 ;
14722 int result;
14723 void *argp1 = 0 ;
14724 int res1 = 0 ;
14725 PyObject *swig_obj[1] ;
14726
14727 if (!args) SWIG_fail;
14728 swig_obj[0] = args;
14729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14730 if (!SWIG_IsOK(res1)) {
14731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14732 }
14733 arg1 = reinterpret_cast< wxGrid * >(argp1);
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (int)(arg1)->GetDefaultRowSize();
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 resultobj = SWIG_From_int(static_cast< int >(result));
14741 return resultobj;
14742 fail:
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj = 0;
14749 wxGrid *arg1 = (wxGrid *) 0 ;
14750 int arg2 ;
14751 int result;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 int val2 ;
14755 int ecode2 = 0 ;
14756 PyObject * obj0 = 0 ;
14757 PyObject * obj1 = 0 ;
14758 char * kwnames[] = {
14759 (char *) "self",(char *) "row", NULL
14760 };
14761
14762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14764 if (!SWIG_IsOK(res1)) {
14765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14766 }
14767 arg1 = reinterpret_cast< wxGrid * >(argp1);
14768 ecode2 = SWIG_AsVal_int(obj1, &val2);
14769 if (!SWIG_IsOK(ecode2)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14771 }
14772 arg2 = static_cast< int >(val2);
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (int)(arg1)->GetRowSize(arg2);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 resultobj = SWIG_From_int(static_cast< int >(result));
14780 return resultobj;
14781 fail:
14782 return NULL;
14783 }
14784
14785
14786 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14787 PyObject *resultobj = 0;
14788 wxGrid *arg1 = (wxGrid *) 0 ;
14789 int result;
14790 void *argp1 = 0 ;
14791 int res1 = 0 ;
14792 PyObject *swig_obj[1] ;
14793
14794 if (!args) SWIG_fail;
14795 swig_obj[0] = args;
14796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14797 if (!SWIG_IsOK(res1)) {
14798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14799 }
14800 arg1 = reinterpret_cast< wxGrid * >(argp1);
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (int)(arg1)->GetDefaultColSize();
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 resultobj = SWIG_From_int(static_cast< int >(result));
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14815 PyObject *resultobj = 0;
14816 wxGrid *arg1 = (wxGrid *) 0 ;
14817 int arg2 ;
14818 int result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 int val2 ;
14822 int ecode2 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 char * kwnames[] = {
14826 (char *) "self",(char *) "col", NULL
14827 };
14828
14829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14833 }
14834 arg1 = reinterpret_cast< wxGrid * >(argp1);
14835 ecode2 = SWIG_AsVal_int(obj1, &val2);
14836 if (!SWIG_IsOK(ecode2)) {
14837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14838 }
14839 arg2 = static_cast< int >(val2);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (int)(arg1)->GetColSize(arg2);
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 resultobj = SWIG_From_int(static_cast< int >(result));
14847 return resultobj;
14848 fail:
14849 return NULL;
14850 }
14851
14852
14853 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14854 PyObject *resultobj = 0;
14855 wxGrid *arg1 = (wxGrid *) 0 ;
14856 wxColour result;
14857 void *argp1 = 0 ;
14858 int res1 = 0 ;
14859 PyObject *swig_obj[1] ;
14860
14861 if (!args) SWIG_fail;
14862 swig_obj[0] = args;
14863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14864 if (!SWIG_IsOK(res1)) {
14865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14866 }
14867 arg1 = reinterpret_cast< wxGrid * >(argp1);
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 result = (arg1)->GetDefaultCellBackgroundColour();
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14882 PyObject *resultobj = 0;
14883 wxGrid *arg1 = (wxGrid *) 0 ;
14884 int arg2 ;
14885 int arg3 ;
14886 wxColour result;
14887 void *argp1 = 0 ;
14888 int res1 = 0 ;
14889 int val2 ;
14890 int ecode2 = 0 ;
14891 int val3 ;
14892 int ecode3 = 0 ;
14893 PyObject * obj0 = 0 ;
14894 PyObject * obj1 = 0 ;
14895 PyObject * obj2 = 0 ;
14896 char * kwnames[] = {
14897 (char *) "self",(char *) "row",(char *) "col", NULL
14898 };
14899
14900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14902 if (!SWIG_IsOK(res1)) {
14903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14904 }
14905 arg1 = reinterpret_cast< wxGrid * >(argp1);
14906 ecode2 = SWIG_AsVal_int(obj1, &val2);
14907 if (!SWIG_IsOK(ecode2)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14909 }
14910 arg2 = static_cast< int >(val2);
14911 ecode3 = SWIG_AsVal_int(obj2, &val3);
14912 if (!SWIG_IsOK(ecode3)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14914 }
14915 arg3 = static_cast< int >(val3);
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14923 return resultobj;
14924 fail:
14925 return NULL;
14926 }
14927
14928
14929 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14930 PyObject *resultobj = 0;
14931 wxGrid *arg1 = (wxGrid *) 0 ;
14932 wxColour result;
14933 void *argp1 = 0 ;
14934 int res1 = 0 ;
14935 PyObject *swig_obj[1] ;
14936
14937 if (!args) SWIG_fail;
14938 swig_obj[0] = args;
14939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14942 }
14943 arg1 = reinterpret_cast< wxGrid * >(argp1);
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (arg1)->GetDefaultCellTextColour();
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14951 return resultobj;
14952 fail:
14953 return NULL;
14954 }
14955
14956
14957 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14958 PyObject *resultobj = 0;
14959 wxGrid *arg1 = (wxGrid *) 0 ;
14960 int arg2 ;
14961 int arg3 ;
14962 wxColour result;
14963 void *argp1 = 0 ;
14964 int res1 = 0 ;
14965 int val2 ;
14966 int ecode2 = 0 ;
14967 int val3 ;
14968 int ecode3 = 0 ;
14969 PyObject * obj0 = 0 ;
14970 PyObject * obj1 = 0 ;
14971 PyObject * obj2 = 0 ;
14972 char * kwnames[] = {
14973 (char *) "self",(char *) "row",(char *) "col", NULL
14974 };
14975
14976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14980 }
14981 arg1 = reinterpret_cast< wxGrid * >(argp1);
14982 ecode2 = SWIG_AsVal_int(obj1, &val2);
14983 if (!SWIG_IsOK(ecode2)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14985 }
14986 arg2 = static_cast< int >(val2);
14987 ecode3 = SWIG_AsVal_int(obj2, &val3);
14988 if (!SWIG_IsOK(ecode3)) {
14989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14990 }
14991 arg3 = static_cast< int >(val3);
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 result = (arg1)->GetCellTextColour(arg2,arg3);
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14999 return resultobj;
15000 fail:
15001 return NULL;
15002 }
15003
15004
15005 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15006 PyObject *resultobj = 0;
15007 wxGrid *arg1 = (wxGrid *) 0 ;
15008 wxFont result;
15009 void *argp1 = 0 ;
15010 int res1 = 0 ;
15011 PyObject *swig_obj[1] ;
15012
15013 if (!args) SWIG_fail;
15014 swig_obj[0] = args;
15015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15016 if (!SWIG_IsOK(res1)) {
15017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15018 }
15019 arg1 = reinterpret_cast< wxGrid * >(argp1);
15020 {
15021 PyThreadState* __tstate = wxPyBeginAllowThreads();
15022 result = (arg1)->GetDefaultCellFont();
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj = 0;
15035 wxGrid *arg1 = (wxGrid *) 0 ;
15036 int arg2 ;
15037 int arg3 ;
15038 wxFont result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 int val2 ;
15042 int ecode2 = 0 ;
15043 int val3 ;
15044 int ecode3 = 0 ;
15045 PyObject * obj0 = 0 ;
15046 PyObject * obj1 = 0 ;
15047 PyObject * obj2 = 0 ;
15048 char * kwnames[] = {
15049 (char *) "self",(char *) "row",(char *) "col", NULL
15050 };
15051
15052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15054 if (!SWIG_IsOK(res1)) {
15055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15056 }
15057 arg1 = reinterpret_cast< wxGrid * >(argp1);
15058 ecode2 = SWIG_AsVal_int(obj1, &val2);
15059 if (!SWIG_IsOK(ecode2)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15061 }
15062 arg2 = static_cast< int >(val2);
15063 ecode3 = SWIG_AsVal_int(obj2, &val3);
15064 if (!SWIG_IsOK(ecode3)) {
15065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15066 }
15067 arg3 = static_cast< int >(val3);
15068 {
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = (arg1)->GetCellFont(arg2,arg3);
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 PyObject *resultobj = 0;
15083 wxGrid *arg1 = (wxGrid *) 0 ;
15084 int *arg2 = (int *) 0 ;
15085 int *arg3 = (int *) 0 ;
15086 void *argp1 = 0 ;
15087 int res1 = 0 ;
15088 int temp2 ;
15089 int res2 = SWIG_TMPOBJ ;
15090 int temp3 ;
15091 int res3 = SWIG_TMPOBJ ;
15092 PyObject *swig_obj[1] ;
15093
15094 arg2 = &temp2;
15095 arg3 = &temp3;
15096 if (!args) SWIG_fail;
15097 swig_obj[0] = args;
15098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15101 }
15102 arg1 = reinterpret_cast< wxGrid * >(argp1);
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 resultobj = SWIG_Py_Void();
15110 if (SWIG_IsTmpObj(res2)) {
15111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15112 } else {
15113 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15115 }
15116 if (SWIG_IsTmpObj(res3)) {
15117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15118 } else {
15119 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15121 }
15122 return resultobj;
15123 fail:
15124 return NULL;
15125 }
15126
15127
15128 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj = 0;
15130 wxGrid *arg1 = (wxGrid *) 0 ;
15131 int arg2 ;
15132 int arg3 ;
15133 int *arg4 = (int *) 0 ;
15134 int *arg5 = (int *) 0 ;
15135 void *argp1 = 0 ;
15136 int res1 = 0 ;
15137 int val2 ;
15138 int ecode2 = 0 ;
15139 int val3 ;
15140 int ecode3 = 0 ;
15141 int temp4 ;
15142 int res4 = SWIG_TMPOBJ ;
15143 int temp5 ;
15144 int res5 = SWIG_TMPOBJ ;
15145 PyObject * obj0 = 0 ;
15146 PyObject * obj1 = 0 ;
15147 PyObject * obj2 = 0 ;
15148 char * kwnames[] = {
15149 (char *) "self",(char *) "row",(char *) "col", NULL
15150 };
15151
15152 arg4 = &temp4;
15153 arg5 = &temp5;
15154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15156 if (!SWIG_IsOK(res1)) {
15157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15158 }
15159 arg1 = reinterpret_cast< wxGrid * >(argp1);
15160 ecode2 = SWIG_AsVal_int(obj1, &val2);
15161 if (!SWIG_IsOK(ecode2)) {
15162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15163 }
15164 arg2 = static_cast< int >(val2);
15165 ecode3 = SWIG_AsVal_int(obj2, &val3);
15166 if (!SWIG_IsOK(ecode3)) {
15167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15168 }
15169 arg3 = static_cast< int >(val3);
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_Py_Void();
15177 if (SWIG_IsTmpObj(res4)) {
15178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15179 } else {
15180 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15182 }
15183 if (SWIG_IsTmpObj(res5)) {
15184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15185 } else {
15186 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxGrid *arg1 = (wxGrid *) 0 ;
15198 bool result;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 PyObject *swig_obj[1] ;
15202
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15208 }
15209 arg1 = reinterpret_cast< wxGrid * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (bool)(arg1)->GetDefaultCellOverflow();
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15218 }
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj = 0;
15227 wxGrid *arg1 = (wxGrid *) 0 ;
15228 int arg2 ;
15229 int arg3 ;
15230 bool result;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 int val2 ;
15234 int ecode2 = 0 ;
15235 int val3 ;
15236 int ecode3 = 0 ;
15237 PyObject * obj0 = 0 ;
15238 PyObject * obj1 = 0 ;
15239 PyObject * obj2 = 0 ;
15240 char * kwnames[] = {
15241 (char *) "self",(char *) "row",(char *) "col", NULL
15242 };
15243
15244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15246 if (!SWIG_IsOK(res1)) {
15247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15248 }
15249 arg1 = reinterpret_cast< wxGrid * >(argp1);
15250 ecode2 = SWIG_AsVal_int(obj1, &val2);
15251 if (!SWIG_IsOK(ecode2)) {
15252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15253 }
15254 arg2 = static_cast< int >(val2);
15255 ecode3 = SWIG_AsVal_int(obj2, &val3);
15256 if (!SWIG_IsOK(ecode3)) {
15257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15258 }
15259 arg3 = static_cast< int >(val3);
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15263 wxPyEndAllowThreads(__tstate);
15264 if (PyErr_Occurred()) SWIG_fail;
15265 }
15266 {
15267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15268 }
15269 return resultobj;
15270 fail:
15271 return NULL;
15272 }
15273
15274
15275 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj = 0;
15277 wxGrid *arg1 = (wxGrid *) 0 ;
15278 int arg2 ;
15279 int arg3 ;
15280 int *arg4 = (int *) 0 ;
15281 int *arg5 = (int *) 0 ;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 int val2 ;
15285 int ecode2 = 0 ;
15286 int val3 ;
15287 int ecode3 = 0 ;
15288 int temp4 ;
15289 int res4 = SWIG_TMPOBJ ;
15290 int temp5 ;
15291 int res5 = SWIG_TMPOBJ ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 PyObject * obj2 = 0 ;
15295 char * kwnames[] = {
15296 (char *) "self",(char *) "row",(char *) "col", NULL
15297 };
15298
15299 arg4 = &temp4;
15300 arg5 = &temp5;
15301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15303 if (!SWIG_IsOK(res1)) {
15304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15305 }
15306 arg1 = reinterpret_cast< wxGrid * >(argp1);
15307 ecode2 = SWIG_AsVal_int(obj1, &val2);
15308 if (!SWIG_IsOK(ecode2)) {
15309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15310 }
15311 arg2 = static_cast< int >(val2);
15312 ecode3 = SWIG_AsVal_int(obj2, &val3);
15313 if (!SWIG_IsOK(ecode3)) {
15314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15315 }
15316 arg3 = static_cast< int >(val3);
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = SWIG_Py_Void();
15324 if (SWIG_IsTmpObj(res4)) {
15325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15326 } else {
15327 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15329 }
15330 if (SWIG_IsTmpObj(res5)) {
15331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15332 } else {
15333 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15335 }
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj = 0;
15344 wxGrid *arg1 = (wxGrid *) 0 ;
15345 int arg2 ;
15346 bool arg3 = (bool) false ;
15347 void *argp1 = 0 ;
15348 int res1 = 0 ;
15349 int val2 ;
15350 int ecode2 = 0 ;
15351 bool val3 ;
15352 int ecode3 = 0 ;
15353 PyObject * obj0 = 0 ;
15354 PyObject * obj1 = 0 ;
15355 PyObject * obj2 = 0 ;
15356 char * kwnames[] = {
15357 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15358 };
15359
15360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15364 }
15365 arg1 = reinterpret_cast< wxGrid * >(argp1);
15366 ecode2 = SWIG_AsVal_int(obj1, &val2);
15367 if (!SWIG_IsOK(ecode2)) {
15368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15369 }
15370 arg2 = static_cast< int >(val2);
15371 if (obj2) {
15372 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15373 if (!SWIG_IsOK(ecode3)) {
15374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15375 }
15376 arg3 = static_cast< bool >(val3);
15377 }
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 (arg1)->SetDefaultRowSize(arg2,arg3);
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_Py_Void();
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj = 0;
15393 wxGrid *arg1 = (wxGrid *) 0 ;
15394 int arg2 ;
15395 int arg3 ;
15396 void *argp1 = 0 ;
15397 int res1 = 0 ;
15398 int val2 ;
15399 int ecode2 = 0 ;
15400 int val3 ;
15401 int ecode3 = 0 ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 PyObject * obj2 = 0 ;
15405 char * kwnames[] = {
15406 (char *) "self",(char *) "row",(char *) "height", NULL
15407 };
15408
15409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15413 }
15414 arg1 = reinterpret_cast< wxGrid * >(argp1);
15415 ecode2 = SWIG_AsVal_int(obj1, &val2);
15416 if (!SWIG_IsOK(ecode2)) {
15417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15418 }
15419 arg2 = static_cast< int >(val2);
15420 ecode3 = SWIG_AsVal_int(obj2, &val3);
15421 if (!SWIG_IsOK(ecode3)) {
15422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15423 }
15424 arg3 = static_cast< int >(val3);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 (arg1)->SetRowSize(arg2,arg3);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = SWIG_Py_Void();
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj = 0;
15440 wxGrid *arg1 = (wxGrid *) 0 ;
15441 int arg2 ;
15442 bool arg3 = (bool) false ;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 int val2 ;
15446 int ecode2 = 0 ;
15447 bool val3 ;
15448 int ecode3 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 PyObject * obj2 = 0 ;
15452 char * kwnames[] = {
15453 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15454 };
15455
15456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15460 }
15461 arg1 = reinterpret_cast< wxGrid * >(argp1);
15462 ecode2 = SWIG_AsVal_int(obj1, &val2);
15463 if (!SWIG_IsOK(ecode2)) {
15464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15465 }
15466 arg2 = static_cast< int >(val2);
15467 if (obj2) {
15468 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15469 if (!SWIG_IsOK(ecode3)) {
15470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15471 }
15472 arg3 = static_cast< bool >(val3);
15473 }
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 (arg1)->SetDefaultColSize(arg2,arg3);
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_Py_Void();
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxGrid *arg1 = (wxGrid *) 0 ;
15490 int arg2 ;
15491 int arg3 ;
15492 void *argp1 = 0 ;
15493 int res1 = 0 ;
15494 int val2 ;
15495 int ecode2 = 0 ;
15496 int val3 ;
15497 int ecode3 = 0 ;
15498 PyObject * obj0 = 0 ;
15499 PyObject * obj1 = 0 ;
15500 PyObject * obj2 = 0 ;
15501 char * kwnames[] = {
15502 (char *) "self",(char *) "col",(char *) "width", NULL
15503 };
15504
15505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15509 }
15510 arg1 = reinterpret_cast< wxGrid * >(argp1);
15511 ecode2 = SWIG_AsVal_int(obj1, &val2);
15512 if (!SWIG_IsOK(ecode2)) {
15513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15514 }
15515 arg2 = static_cast< int >(val2);
15516 ecode3 = SWIG_AsVal_int(obj2, &val3);
15517 if (!SWIG_IsOK(ecode3)) {
15518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15519 }
15520 arg3 = static_cast< int >(val3);
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 (arg1)->SetColSize(arg2,arg3);
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 resultobj = SWIG_Py_Void();
15528 return resultobj;
15529 fail:
15530 return NULL;
15531 }
15532
15533
15534 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj = 0;
15536 wxGrid *arg1 = (wxGrid *) 0 ;
15537 int arg2 ;
15538 int result;
15539 void *argp1 = 0 ;
15540 int res1 = 0 ;
15541 int val2 ;
15542 int ecode2 = 0 ;
15543 PyObject * obj0 = 0 ;
15544 PyObject * obj1 = 0 ;
15545 char * kwnames[] = {
15546 (char *) "self",(char *) "colPos", NULL
15547 };
15548
15549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15553 }
15554 arg1 = reinterpret_cast< wxGrid * >(argp1);
15555 ecode2 = SWIG_AsVal_int(obj1, &val2);
15556 if (!SWIG_IsOK(ecode2)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15558 }
15559 arg2 = static_cast< int >(val2);
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_From_int(static_cast< int >(result));
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxGrid *arg1 = (wxGrid *) 0 ;
15576 int arg2 ;
15577 int arg3 ;
15578 void *argp1 = 0 ;
15579 int res1 = 0 ;
15580 int val2 ;
15581 int ecode2 = 0 ;
15582 int val3 ;
15583 int ecode3 = 0 ;
15584 PyObject * obj0 = 0 ;
15585 PyObject * obj1 = 0 ;
15586 PyObject * obj2 = 0 ;
15587 char * kwnames[] = {
15588 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15589 };
15590
15591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15593 if (!SWIG_IsOK(res1)) {
15594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15595 }
15596 arg1 = reinterpret_cast< wxGrid * >(argp1);
15597 ecode2 = SWIG_AsVal_int(obj1, &val2);
15598 if (!SWIG_IsOK(ecode2)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15600 }
15601 arg2 = static_cast< int >(val2);
15602 ecode3 = SWIG_AsVal_int(obj2, &val3);
15603 if (!SWIG_IsOK(ecode3)) {
15604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15605 }
15606 arg3 = static_cast< int >(val3);
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 (arg1)->SetColPos(arg2,arg3);
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_Py_Void();
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15621 PyObject *resultobj = 0;
15622 wxGrid *arg1 = (wxGrid *) 0 ;
15623 int arg2 ;
15624 int result;
15625 void *argp1 = 0 ;
15626 int res1 = 0 ;
15627 int val2 ;
15628 int ecode2 = 0 ;
15629 PyObject * obj0 = 0 ;
15630 PyObject * obj1 = 0 ;
15631 char * kwnames[] = {
15632 (char *) "self",(char *) "colID", NULL
15633 };
15634
15635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15637 if (!SWIG_IsOK(res1)) {
15638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15639 }
15640 arg1 = reinterpret_cast< wxGrid * >(argp1);
15641 ecode2 = SWIG_AsVal_int(obj1, &val2);
15642 if (!SWIG_IsOK(ecode2)) {
15643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15644 }
15645 arg2 = static_cast< int >(val2);
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 resultobj = SWIG_From_int(static_cast< int >(result));
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15660 PyObject *resultobj = 0;
15661 wxGrid *arg1 = (wxGrid *) 0 ;
15662 int arg2 ;
15663 bool arg3 = (bool) true ;
15664 void *argp1 = 0 ;
15665 int res1 = 0 ;
15666 int val2 ;
15667 int ecode2 = 0 ;
15668 bool val3 ;
15669 int ecode3 = 0 ;
15670 PyObject * obj0 = 0 ;
15671 PyObject * obj1 = 0 ;
15672 PyObject * obj2 = 0 ;
15673 char * kwnames[] = {
15674 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15675 };
15676
15677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15679 if (!SWIG_IsOK(res1)) {
15680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15681 }
15682 arg1 = reinterpret_cast< wxGrid * >(argp1);
15683 ecode2 = SWIG_AsVal_int(obj1, &val2);
15684 if (!SWIG_IsOK(ecode2)) {
15685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15686 }
15687 arg2 = static_cast< int >(val2);
15688 if (obj2) {
15689 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15690 if (!SWIG_IsOK(ecode3)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15692 }
15693 arg3 = static_cast< bool >(val3);
15694 }
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 (arg1)->AutoSizeColumn(arg2,arg3);
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_Py_Void();
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj = 0;
15710 wxGrid *arg1 = (wxGrid *) 0 ;
15711 int arg2 ;
15712 bool arg3 = (bool) true ;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 int val2 ;
15716 int ecode2 = 0 ;
15717 bool val3 ;
15718 int ecode3 = 0 ;
15719 PyObject * obj0 = 0 ;
15720 PyObject * obj1 = 0 ;
15721 PyObject * obj2 = 0 ;
15722 char * kwnames[] = {
15723 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15724 };
15725
15726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15730 }
15731 arg1 = reinterpret_cast< wxGrid * >(argp1);
15732 ecode2 = SWIG_AsVal_int(obj1, &val2);
15733 if (!SWIG_IsOK(ecode2)) {
15734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15735 }
15736 arg2 = static_cast< int >(val2);
15737 if (obj2) {
15738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15739 if (!SWIG_IsOK(ecode3)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15741 }
15742 arg3 = static_cast< bool >(val3);
15743 }
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 (arg1)->AutoSizeRow(arg2,arg3);
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_Py_Void();
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15758 PyObject *resultobj = 0;
15759 wxGrid *arg1 = (wxGrid *) 0 ;
15760 bool arg2 = (bool) true ;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 bool val2 ;
15764 int ecode2 = 0 ;
15765 PyObject * obj0 = 0 ;
15766 PyObject * obj1 = 0 ;
15767 char * kwnames[] = {
15768 (char *) "self",(char *) "setAsMin", NULL
15769 };
15770
15771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15773 if (!SWIG_IsOK(res1)) {
15774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15775 }
15776 arg1 = reinterpret_cast< wxGrid * >(argp1);
15777 if (obj1) {
15778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15779 if (!SWIG_IsOK(ecode2)) {
15780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15781 }
15782 arg2 = static_cast< bool >(val2);
15783 }
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 (arg1)->AutoSizeColumns(arg2);
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_AutoSizeRows(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_AutoSizeRows",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_AutoSizeRows" "', 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_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15821 }
15822 arg2 = static_cast< bool >(val2);
15823 }
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 (arg1)->AutoSizeRows(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_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15838 PyObject *resultobj = 0;
15839 wxGrid *arg1 = (wxGrid *) 0 ;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15849 }
15850 arg1 = reinterpret_cast< wxGrid * >(argp1);
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 (arg1)->AutoSize();
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_Py_Void();
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 wxGrid *arg1 = (wxGrid *) 0 ;
15867 int arg2 ;
15868 void *argp1 = 0 ;
15869 int res1 = 0 ;
15870 int val2 ;
15871 int ecode2 = 0 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 char * kwnames[] = {
15875 (char *) "self",(char *) "row", NULL
15876 };
15877
15878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15882 }
15883 arg1 = reinterpret_cast< wxGrid * >(argp1);
15884 ecode2 = SWIG_AsVal_int(obj1, &val2);
15885 if (!SWIG_IsOK(ecode2)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15887 }
15888 arg2 = static_cast< int >(val2);
15889 {
15890 PyThreadState* __tstate = wxPyBeginAllowThreads();
15891 (arg1)->AutoSizeRowLabelSize(arg2);
15892 wxPyEndAllowThreads(__tstate);
15893 if (PyErr_Occurred()) SWIG_fail;
15894 }
15895 resultobj = SWIG_Py_Void();
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj = 0;
15904 wxGrid *arg1 = (wxGrid *) 0 ;
15905 int arg2 ;
15906 void *argp1 = 0 ;
15907 int res1 = 0 ;
15908 int val2 ;
15909 int ecode2 = 0 ;
15910 PyObject * obj0 = 0 ;
15911 PyObject * obj1 = 0 ;
15912 char * kwnames[] = {
15913 (char *) "self",(char *) "col", NULL
15914 };
15915
15916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15918 if (!SWIG_IsOK(res1)) {
15919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15920 }
15921 arg1 = reinterpret_cast< wxGrid * >(argp1);
15922 ecode2 = SWIG_AsVal_int(obj1, &val2);
15923 if (!SWIG_IsOK(ecode2)) {
15924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15925 }
15926 arg2 = static_cast< int >(val2);
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 (arg1)->AutoSizeColLabelSize(arg2);
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 resultobj = SWIG_Py_Void();
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15941 PyObject *resultobj = 0;
15942 wxGrid *arg1 = (wxGrid *) 0 ;
15943 int arg2 ;
15944 int arg3 ;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 int val2 ;
15948 int ecode2 = 0 ;
15949 int val3 ;
15950 int ecode3 = 0 ;
15951 PyObject * obj0 = 0 ;
15952 PyObject * obj1 = 0 ;
15953 PyObject * obj2 = 0 ;
15954 char * kwnames[] = {
15955 (char *) "self",(char *) "col",(char *) "width", NULL
15956 };
15957
15958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15960 if (!SWIG_IsOK(res1)) {
15961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15962 }
15963 arg1 = reinterpret_cast< wxGrid * >(argp1);
15964 ecode2 = SWIG_AsVal_int(obj1, &val2);
15965 if (!SWIG_IsOK(ecode2)) {
15966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15967 }
15968 arg2 = static_cast< int >(val2);
15969 ecode3 = SWIG_AsVal_int(obj2, &val3);
15970 if (!SWIG_IsOK(ecode3)) {
15971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15972 }
15973 arg3 = static_cast< int >(val3);
15974 {
15975 PyThreadState* __tstate = wxPyBeginAllowThreads();
15976 (arg1)->SetColMinimalWidth(arg2,arg3);
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 resultobj = SWIG_Py_Void();
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj = 0;
15989 wxGrid *arg1 = (wxGrid *) 0 ;
15990 int arg2 ;
15991 int arg3 ;
15992 void *argp1 = 0 ;
15993 int res1 = 0 ;
15994 int val2 ;
15995 int ecode2 = 0 ;
15996 int val3 ;
15997 int ecode3 = 0 ;
15998 PyObject * obj0 = 0 ;
15999 PyObject * obj1 = 0 ;
16000 PyObject * obj2 = 0 ;
16001 char * kwnames[] = {
16002 (char *) "self",(char *) "row",(char *) "width", NULL
16003 };
16004
16005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16007 if (!SWIG_IsOK(res1)) {
16008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16009 }
16010 arg1 = reinterpret_cast< wxGrid * >(argp1);
16011 ecode2 = SWIG_AsVal_int(obj1, &val2);
16012 if (!SWIG_IsOK(ecode2)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16014 }
16015 arg2 = static_cast< int >(val2);
16016 ecode3 = SWIG_AsVal_int(obj2, &val3);
16017 if (!SWIG_IsOK(ecode3)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16019 }
16020 arg3 = static_cast< int >(val3);
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 (arg1)->SetRowMinimalHeight(arg2,arg3);
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_Py_Void();
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj = 0;
16036 wxGrid *arg1 = (wxGrid *) 0 ;
16037 int arg2 ;
16038 void *argp1 = 0 ;
16039 int res1 = 0 ;
16040 int val2 ;
16041 int ecode2 = 0 ;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 char * kwnames[] = {
16045 (char *) "self",(char *) "width", NULL
16046 };
16047
16048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16050 if (!SWIG_IsOK(res1)) {
16051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16052 }
16053 arg1 = reinterpret_cast< wxGrid * >(argp1);
16054 ecode2 = SWIG_AsVal_int(obj1, &val2);
16055 if (!SWIG_IsOK(ecode2)) {
16056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16057 }
16058 arg2 = static_cast< int >(val2);
16059 {
16060 PyThreadState* __tstate = wxPyBeginAllowThreads();
16061 (arg1)->SetColMinimalAcceptableWidth(arg2);
16062 wxPyEndAllowThreads(__tstate);
16063 if (PyErr_Occurred()) SWIG_fail;
16064 }
16065 resultobj = SWIG_Py_Void();
16066 return resultobj;
16067 fail:
16068 return NULL;
16069 }
16070
16071
16072 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16073 PyObject *resultobj = 0;
16074 wxGrid *arg1 = (wxGrid *) 0 ;
16075 int arg2 ;
16076 void *argp1 = 0 ;
16077 int res1 = 0 ;
16078 int val2 ;
16079 int ecode2 = 0 ;
16080 PyObject * obj0 = 0 ;
16081 PyObject * obj1 = 0 ;
16082 char * kwnames[] = {
16083 (char *) "self",(char *) "width", NULL
16084 };
16085
16086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16088 if (!SWIG_IsOK(res1)) {
16089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16090 }
16091 arg1 = reinterpret_cast< wxGrid * >(argp1);
16092 ecode2 = SWIG_AsVal_int(obj1, &val2);
16093 if (!SWIG_IsOK(ecode2)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16095 }
16096 arg2 = static_cast< int >(val2);
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_Py_Void();
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16111 PyObject *resultobj = 0;
16112 wxGrid *arg1 = (wxGrid *) 0 ;
16113 int result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 PyObject *swig_obj[1] ;
16117
16118 if (!args) SWIG_fail;
16119 swig_obj[0] = args;
16120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16121 if (!SWIG_IsOK(res1)) {
16122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16123 }
16124 arg1 = reinterpret_cast< wxGrid * >(argp1);
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_From_int(static_cast< int >(result));
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *resultobj = 0;
16140 wxGrid *arg1 = (wxGrid *) 0 ;
16141 int result;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 PyObject *swig_obj[1] ;
16145
16146 if (!args) SWIG_fail;
16147 swig_obj[0] = args;
16148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16151 }
16152 arg1 = reinterpret_cast< wxGrid * >(argp1);
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = SWIG_From_int(static_cast< int >(result));
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxGrid *arg1 = (wxGrid *) 0 ;
16169 wxColour *arg2 = 0 ;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 wxColour temp2 ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *)"arg2", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16183 }
16184 arg1 = reinterpret_cast< wxGrid * >(argp1);
16185 {
16186 arg2 = &temp2;
16187 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16188 }
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 resultobj = SWIG_Py_Void();
16196 return resultobj;
16197 fail:
16198 return NULL;
16199 }
16200
16201
16202 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16203 PyObject *resultobj = 0;
16204 wxGrid *arg1 = (wxGrid *) 0 ;
16205 int arg2 ;
16206 int arg3 ;
16207 wxColour *arg4 = 0 ;
16208 void *argp1 = 0 ;
16209 int res1 = 0 ;
16210 int val2 ;
16211 int ecode2 = 0 ;
16212 int val3 ;
16213 int ecode3 = 0 ;
16214 wxColour temp4 ;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 PyObject * obj2 = 0 ;
16218 PyObject * obj3 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16227 }
16228 arg1 = reinterpret_cast< wxGrid * >(argp1);
16229 ecode2 = SWIG_AsVal_int(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16232 }
16233 arg2 = static_cast< int >(val2);
16234 ecode3 = SWIG_AsVal_int(obj2, &val3);
16235 if (!SWIG_IsOK(ecode3)) {
16236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16237 }
16238 arg3 = static_cast< int >(val3);
16239 {
16240 arg4 = &temp4;
16241 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16242 }
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 resultobj = SWIG_Py_Void();
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxGrid *arg1 = (wxGrid *) 0 ;
16259 wxColour *arg2 = 0 ;
16260 void *argp1 = 0 ;
16261 int res1 = 0 ;
16262 wxColour temp2 ;
16263 PyObject * obj0 = 0 ;
16264 PyObject * obj1 = 0 ;
16265 char * kwnames[] = {
16266 (char *) "self",(char *)"arg2", NULL
16267 };
16268
16269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16271 if (!SWIG_IsOK(res1)) {
16272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16273 }
16274 arg1 = reinterpret_cast< wxGrid * >(argp1);
16275 {
16276 arg2 = &temp2;
16277 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16282 wxPyEndAllowThreads(__tstate);
16283 if (PyErr_Occurred()) SWIG_fail;
16284 }
16285 resultobj = SWIG_Py_Void();
16286 return resultobj;
16287 fail:
16288 return NULL;
16289 }
16290
16291
16292 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj = 0;
16294 wxGrid *arg1 = (wxGrid *) 0 ;
16295 int arg2 ;
16296 int arg3 ;
16297 wxColour *arg4 = 0 ;
16298 void *argp1 = 0 ;
16299 int res1 = 0 ;
16300 int val2 ;
16301 int ecode2 = 0 ;
16302 int val3 ;
16303 int ecode3 = 0 ;
16304 wxColour temp4 ;
16305 PyObject * obj0 = 0 ;
16306 PyObject * obj1 = 0 ;
16307 PyObject * obj2 = 0 ;
16308 PyObject * obj3 = 0 ;
16309 char * kwnames[] = {
16310 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16311 };
16312
16313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16315 if (!SWIG_IsOK(res1)) {
16316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16317 }
16318 arg1 = reinterpret_cast< wxGrid * >(argp1);
16319 ecode2 = SWIG_AsVal_int(obj1, &val2);
16320 if (!SWIG_IsOK(ecode2)) {
16321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16322 }
16323 arg2 = static_cast< int >(val2);
16324 ecode3 = SWIG_AsVal_int(obj2, &val3);
16325 if (!SWIG_IsOK(ecode3)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16327 }
16328 arg3 = static_cast< int >(val3);
16329 {
16330 arg4 = &temp4;
16331 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16332 }
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 resultobj = SWIG_Py_Void();
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj = 0;
16348 wxGrid *arg1 = (wxGrid *) 0 ;
16349 wxFont *arg2 = 0 ;
16350 void *argp1 = 0 ;
16351 int res1 = 0 ;
16352 void *argp2 = 0 ;
16353 int res2 = 0 ;
16354 PyObject * obj0 = 0 ;
16355 PyObject * obj1 = 0 ;
16356 char * kwnames[] = {
16357 (char *) "self",(char *)"arg2", NULL
16358 };
16359
16360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16362 if (!SWIG_IsOK(res1)) {
16363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16364 }
16365 arg1 = reinterpret_cast< wxGrid * >(argp1);
16366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16367 if (!SWIG_IsOK(res2)) {
16368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16369 }
16370 if (!argp2) {
16371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16372 }
16373 arg2 = reinterpret_cast< wxFont * >(argp2);
16374 {
16375 PyThreadState* __tstate = wxPyBeginAllowThreads();
16376 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16377 wxPyEndAllowThreads(__tstate);
16378 if (PyErr_Occurred()) SWIG_fail;
16379 }
16380 resultobj = SWIG_Py_Void();
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxGrid *arg1 = (wxGrid *) 0 ;
16390 int arg2 ;
16391 int arg3 ;
16392 wxFont *arg4 = 0 ;
16393 void *argp1 = 0 ;
16394 int res1 = 0 ;
16395 int val2 ;
16396 int ecode2 = 0 ;
16397 int val3 ;
16398 int ecode3 = 0 ;
16399 void *argp4 = 0 ;
16400 int res4 = 0 ;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 PyObject * obj2 = 0 ;
16404 PyObject * obj3 = 0 ;
16405 char * kwnames[] = {
16406 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16407 };
16408
16409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16411 if (!SWIG_IsOK(res1)) {
16412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16413 }
16414 arg1 = reinterpret_cast< wxGrid * >(argp1);
16415 ecode2 = SWIG_AsVal_int(obj1, &val2);
16416 if (!SWIG_IsOK(ecode2)) {
16417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16418 }
16419 arg2 = static_cast< int >(val2);
16420 ecode3 = SWIG_AsVal_int(obj2, &val3);
16421 if (!SWIG_IsOK(ecode3)) {
16422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16423 }
16424 arg3 = static_cast< int >(val3);
16425 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16426 if (!SWIG_IsOK(res4)) {
16427 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16428 }
16429 if (!argp4) {
16430 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16431 }
16432 arg4 = reinterpret_cast< wxFont * >(argp4);
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 resultobj = SWIG_Py_Void();
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj = 0;
16448 wxGrid *arg1 = (wxGrid *) 0 ;
16449 int arg2 ;
16450 int arg3 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 int val2 ;
16454 int ecode2 = 0 ;
16455 int val3 ;
16456 int ecode3 = 0 ;
16457 PyObject * obj0 = 0 ;
16458 PyObject * obj1 = 0 ;
16459 PyObject * obj2 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16468 }
16469 arg1 = reinterpret_cast< wxGrid * >(argp1);
16470 ecode2 = SWIG_AsVal_int(obj1, &val2);
16471 if (!SWIG_IsOK(ecode2)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16473 }
16474 arg2 = static_cast< int >(val2);
16475 ecode3 = SWIG_AsVal_int(obj2, &val3);
16476 if (!SWIG_IsOK(ecode3)) {
16477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16478 }
16479 arg3 = static_cast< int >(val3);
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 resultobj = SWIG_Py_Void();
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16494 PyObject *resultobj = 0;
16495 wxGrid *arg1 = (wxGrid *) 0 ;
16496 int arg2 ;
16497 int arg3 ;
16498 int arg4 ;
16499 int arg5 ;
16500 void *argp1 = 0 ;
16501 int res1 = 0 ;
16502 int val2 ;
16503 int ecode2 = 0 ;
16504 int val3 ;
16505 int ecode3 = 0 ;
16506 int val4 ;
16507 int ecode4 = 0 ;
16508 int val5 ;
16509 int ecode5 = 0 ;
16510 PyObject * obj0 = 0 ;
16511 PyObject * obj1 = 0 ;
16512 PyObject * obj2 = 0 ;
16513 PyObject * obj3 = 0 ;
16514 PyObject * obj4 = 0 ;
16515 char * kwnames[] = {
16516 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16517 };
16518
16519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16523 }
16524 arg1 = reinterpret_cast< wxGrid * >(argp1);
16525 ecode2 = SWIG_AsVal_int(obj1, &val2);
16526 if (!SWIG_IsOK(ecode2)) {
16527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16528 }
16529 arg2 = static_cast< int >(val2);
16530 ecode3 = SWIG_AsVal_int(obj2, &val3);
16531 if (!SWIG_IsOK(ecode3)) {
16532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16533 }
16534 arg3 = static_cast< int >(val3);
16535 ecode4 = SWIG_AsVal_int(obj3, &val4);
16536 if (!SWIG_IsOK(ecode4)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16538 }
16539 arg4 = static_cast< int >(val4);
16540 ecode5 = SWIG_AsVal_int(obj4, &val5);
16541 if (!SWIG_IsOK(ecode5)) {
16542 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16543 }
16544 arg5 = static_cast< int >(val5);
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_Py_Void();
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxGrid *arg1 = (wxGrid *) 0 ;
16561 bool arg2 ;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 bool val2 ;
16565 int ecode2 = 0 ;
16566 PyObject * obj0 = 0 ;
16567 PyObject * obj1 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "self",(char *) "allow", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16576 }
16577 arg1 = reinterpret_cast< wxGrid * >(argp1);
16578 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16579 if (!SWIG_IsOK(ecode2)) {
16580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16581 }
16582 arg2 = static_cast< bool >(val2);
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 (arg1)->SetDefaultCellOverflow(arg2);
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 resultobj = SWIG_Py_Void();
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = 0;
16598 wxGrid *arg1 = (wxGrid *) 0 ;
16599 int arg2 ;
16600 int arg3 ;
16601 bool arg4 ;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 int val2 ;
16605 int ecode2 = 0 ;
16606 int val3 ;
16607 int ecode3 = 0 ;
16608 bool val4 ;
16609 int ecode4 = 0 ;
16610 PyObject * obj0 = 0 ;
16611 PyObject * obj1 = 0 ;
16612 PyObject * obj2 = 0 ;
16613 PyObject * obj3 = 0 ;
16614 char * kwnames[] = {
16615 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16616 };
16617
16618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16622 }
16623 arg1 = reinterpret_cast< wxGrid * >(argp1);
16624 ecode2 = SWIG_AsVal_int(obj1, &val2);
16625 if (!SWIG_IsOK(ecode2)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16627 }
16628 arg2 = static_cast< int >(val2);
16629 ecode3 = SWIG_AsVal_int(obj2, &val3);
16630 if (!SWIG_IsOK(ecode3)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16632 }
16633 arg3 = static_cast< int >(val3);
16634 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16635 if (!SWIG_IsOK(ecode4)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16637 }
16638 arg4 = static_cast< bool >(val4);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_Py_Void();
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxGrid *arg1 = (wxGrid *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 int arg4 ;
16658 int arg5 ;
16659 void *argp1 = 0 ;
16660 int res1 = 0 ;
16661 int val2 ;
16662 int ecode2 = 0 ;
16663 int val3 ;
16664 int ecode3 = 0 ;
16665 int val4 ;
16666 int ecode4 = 0 ;
16667 int val5 ;
16668 int ecode5 = 0 ;
16669 PyObject * obj0 = 0 ;
16670 PyObject * obj1 = 0 ;
16671 PyObject * obj2 = 0 ;
16672 PyObject * obj3 = 0 ;
16673 PyObject * obj4 = 0 ;
16674 char * kwnames[] = {
16675 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16676 };
16677
16678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16680 if (!SWIG_IsOK(res1)) {
16681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16682 }
16683 arg1 = reinterpret_cast< wxGrid * >(argp1);
16684 ecode2 = SWIG_AsVal_int(obj1, &val2);
16685 if (!SWIG_IsOK(ecode2)) {
16686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16687 }
16688 arg2 = static_cast< int >(val2);
16689 ecode3 = SWIG_AsVal_int(obj2, &val3);
16690 if (!SWIG_IsOK(ecode3)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16692 }
16693 arg3 = static_cast< int >(val3);
16694 ecode4 = SWIG_AsVal_int(obj3, &val4);
16695 if (!SWIG_IsOK(ecode4)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16697 }
16698 arg4 = static_cast< int >(val4);
16699 ecode5 = SWIG_AsVal_int(obj4, &val5);
16700 if (!SWIG_IsOK(ecode5)) {
16701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16702 }
16703 arg5 = static_cast< int >(val5);
16704 {
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 resultobj = SWIG_Py_Void();
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj = 0;
16719 wxGrid *arg1 = (wxGrid *) 0 ;
16720 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16721 void *argp1 = 0 ;
16722 int res1 = 0 ;
16723 void *argp2 = 0 ;
16724 int res2 = 0 ;
16725 PyObject * obj0 = 0 ;
16726 PyObject * obj1 = 0 ;
16727 char * kwnames[] = {
16728 (char *) "self",(char *) "renderer", NULL
16729 };
16730
16731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16733 if (!SWIG_IsOK(res1)) {
16734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16735 }
16736 arg1 = reinterpret_cast< wxGrid * >(argp1);
16737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16738 if (!SWIG_IsOK(res2)) {
16739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16740 }
16741 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 (arg1)->SetDefaultRenderer(arg2);
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 resultobj = SWIG_Py_Void();
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxGrid *arg1 = (wxGrid *) 0 ;
16758 int arg2 ;
16759 int arg3 ;
16760 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16761 void *argp1 = 0 ;
16762 int res1 = 0 ;
16763 int val2 ;
16764 int ecode2 = 0 ;
16765 int val3 ;
16766 int ecode3 = 0 ;
16767 void *argp4 = 0 ;
16768 int res4 = 0 ;
16769 PyObject * obj0 = 0 ;
16770 PyObject * obj1 = 0 ;
16771 PyObject * obj2 = 0 ;
16772 PyObject * obj3 = 0 ;
16773 char * kwnames[] = {
16774 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16775 };
16776
16777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16779 if (!SWIG_IsOK(res1)) {
16780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16781 }
16782 arg1 = reinterpret_cast< wxGrid * >(argp1);
16783 ecode2 = SWIG_AsVal_int(obj1, &val2);
16784 if (!SWIG_IsOK(ecode2)) {
16785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16786 }
16787 arg2 = static_cast< int >(val2);
16788 ecode3 = SWIG_AsVal_int(obj2, &val3);
16789 if (!SWIG_IsOK(ecode3)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16791 }
16792 arg3 = static_cast< int >(val3);
16793 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16794 if (!SWIG_IsOK(res4)) {
16795 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16796 }
16797 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16801 wxPyEndAllowThreads(__tstate);
16802 if (PyErr_Occurred()) SWIG_fail;
16803 }
16804 resultobj = SWIG_Py_Void();
16805 return resultobj;
16806 fail:
16807 return NULL;
16808 }
16809
16810
16811 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16812 PyObject *resultobj = 0;
16813 wxGrid *arg1 = (wxGrid *) 0 ;
16814 wxGridCellRenderer *result = 0 ;
16815 void *argp1 = 0 ;
16816 int res1 = 0 ;
16817 PyObject *swig_obj[1] ;
16818
16819 if (!args) SWIG_fail;
16820 swig_obj[0] = args;
16821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16824 }
16825 arg1 = reinterpret_cast< wxGrid * >(argp1);
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 {
16833 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16834 }
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16842 PyObject *resultobj = 0;
16843 wxGrid *arg1 = (wxGrid *) 0 ;
16844 int arg2 ;
16845 int arg3 ;
16846 wxGridCellRenderer *result = 0 ;
16847 void *argp1 = 0 ;
16848 int res1 = 0 ;
16849 int val2 ;
16850 int ecode2 = 0 ;
16851 int val3 ;
16852 int ecode3 = 0 ;
16853 PyObject * obj0 = 0 ;
16854 PyObject * obj1 = 0 ;
16855 PyObject * obj2 = 0 ;
16856 char * kwnames[] = {
16857 (char *) "self",(char *) "row",(char *) "col", NULL
16858 };
16859
16860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16862 if (!SWIG_IsOK(res1)) {
16863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16864 }
16865 arg1 = reinterpret_cast< wxGrid * >(argp1);
16866 ecode2 = SWIG_AsVal_int(obj1, &val2);
16867 if (!SWIG_IsOK(ecode2)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16869 }
16870 arg2 = static_cast< int >(val2);
16871 ecode3 = SWIG_AsVal_int(obj2, &val3);
16872 if (!SWIG_IsOK(ecode3)) {
16873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16874 }
16875 arg3 = static_cast< int >(val3);
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16879 wxPyEndAllowThreads(__tstate);
16880 if (PyErr_Occurred()) SWIG_fail;
16881 }
16882 {
16883 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16884 }
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxGrid *arg1 = (wxGrid *) 0 ;
16894 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 void *argp2 = 0 ;
16898 int res2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "editor", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16909 }
16910 arg1 = reinterpret_cast< wxGrid * >(argp1);
16911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16912 if (!SWIG_IsOK(res2)) {
16913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16914 }
16915 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 (arg1)->SetDefaultEditor(arg2);
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 resultobj = SWIG_Py_Void();
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj = 0;
16931 wxGrid *arg1 = (wxGrid *) 0 ;
16932 int arg2 ;
16933 int arg3 ;
16934 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16935 void *argp1 = 0 ;
16936 int res1 = 0 ;
16937 int val2 ;
16938 int ecode2 = 0 ;
16939 int val3 ;
16940 int ecode3 = 0 ;
16941 void *argp4 = 0 ;
16942 int res4 = 0 ;
16943 PyObject * obj0 = 0 ;
16944 PyObject * obj1 = 0 ;
16945 PyObject * obj2 = 0 ;
16946 PyObject * obj3 = 0 ;
16947 char * kwnames[] = {
16948 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16949 };
16950
16951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16953 if (!SWIG_IsOK(res1)) {
16954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16955 }
16956 arg1 = reinterpret_cast< wxGrid * >(argp1);
16957 ecode2 = SWIG_AsVal_int(obj1, &val2);
16958 if (!SWIG_IsOK(ecode2)) {
16959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16960 }
16961 arg2 = static_cast< int >(val2);
16962 ecode3 = SWIG_AsVal_int(obj2, &val3);
16963 if (!SWIG_IsOK(ecode3)) {
16964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16965 }
16966 arg3 = static_cast< int >(val3);
16967 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16968 if (!SWIG_IsOK(res4)) {
16969 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16970 }
16971 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 (arg1)->SetCellEditor(arg2,arg3,arg4);
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 resultobj = SWIG_Py_Void();
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16986 PyObject *resultobj = 0;
16987 wxGrid *arg1 = (wxGrid *) 0 ;
16988 wxGridCellEditor *result = 0 ;
16989 void *argp1 = 0 ;
16990 int res1 = 0 ;
16991 PyObject *swig_obj[1] ;
16992
16993 if (!args) SWIG_fail;
16994 swig_obj[0] = args;
16995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16996 if (!SWIG_IsOK(res1)) {
16997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16998 }
16999 arg1 = reinterpret_cast< wxGrid * >(argp1);
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 {
17007 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17008 }
17009 return resultobj;
17010 fail:
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxGrid *arg1 = (wxGrid *) 0 ;
17018 int arg2 ;
17019 int arg3 ;
17020 wxGridCellEditor *result = 0 ;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 int val2 ;
17024 int ecode2 = 0 ;
17025 int val3 ;
17026 int ecode3 = 0 ;
17027 PyObject * obj0 = 0 ;
17028 PyObject * obj1 = 0 ;
17029 PyObject * obj2 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "row",(char *) "col", NULL
17032 };
17033
17034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17038 }
17039 arg1 = reinterpret_cast< wxGrid * >(argp1);
17040 ecode2 = SWIG_AsVal_int(obj1, &val2);
17041 if (!SWIG_IsOK(ecode2)) {
17042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17043 }
17044 arg2 = static_cast< int >(val2);
17045 ecode3 = SWIG_AsVal_int(obj2, &val3);
17046 if (!SWIG_IsOK(ecode3)) {
17047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17048 }
17049 arg3 = static_cast< int >(val3);
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 {
17057 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17058 }
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj = 0;
17067 wxGrid *arg1 = (wxGrid *) 0 ;
17068 int arg2 ;
17069 int arg3 ;
17070 wxString result;
17071 void *argp1 = 0 ;
17072 int res1 = 0 ;
17073 int val2 ;
17074 int ecode2 = 0 ;
17075 int val3 ;
17076 int ecode3 = 0 ;
17077 PyObject * obj0 = 0 ;
17078 PyObject * obj1 = 0 ;
17079 PyObject * obj2 = 0 ;
17080 char * kwnames[] = {
17081 (char *) "self",(char *) "row",(char *) "col", NULL
17082 };
17083
17084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17086 if (!SWIG_IsOK(res1)) {
17087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17088 }
17089 arg1 = reinterpret_cast< wxGrid * >(argp1);
17090 ecode2 = SWIG_AsVal_int(obj1, &val2);
17091 if (!SWIG_IsOK(ecode2)) {
17092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17093 }
17094 arg2 = static_cast< int >(val2);
17095 ecode3 = SWIG_AsVal_int(obj2, &val3);
17096 if (!SWIG_IsOK(ecode3)) {
17097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17098 }
17099 arg3 = static_cast< int >(val3);
17100 {
17101 PyThreadState* __tstate = wxPyBeginAllowThreads();
17102 result = (arg1)->GetCellValue(arg2,arg3);
17103 wxPyEndAllowThreads(__tstate);
17104 if (PyErr_Occurred()) SWIG_fail;
17105 }
17106 {
17107 #if wxUSE_UNICODE
17108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17109 #else
17110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17111 #endif
17112 }
17113 return resultobj;
17114 fail:
17115 return NULL;
17116 }
17117
17118
17119 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17120 PyObject *resultobj = 0;
17121 wxGrid *arg1 = (wxGrid *) 0 ;
17122 int arg2 ;
17123 int arg3 ;
17124 wxString *arg4 = 0 ;
17125 void *argp1 = 0 ;
17126 int res1 = 0 ;
17127 int val2 ;
17128 int ecode2 = 0 ;
17129 int val3 ;
17130 int ecode3 = 0 ;
17131 bool temp4 = false ;
17132 PyObject * obj0 = 0 ;
17133 PyObject * obj1 = 0 ;
17134 PyObject * obj2 = 0 ;
17135 PyObject * obj3 = 0 ;
17136 char * kwnames[] = {
17137 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17138 };
17139
17140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17142 if (!SWIG_IsOK(res1)) {
17143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17144 }
17145 arg1 = reinterpret_cast< wxGrid * >(argp1);
17146 ecode2 = SWIG_AsVal_int(obj1, &val2);
17147 if (!SWIG_IsOK(ecode2)) {
17148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17149 }
17150 arg2 = static_cast< int >(val2);
17151 ecode3 = SWIG_AsVal_int(obj2, &val3);
17152 if (!SWIG_IsOK(ecode3)) {
17153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17154 }
17155 arg3 = static_cast< int >(val3);
17156 {
17157 arg4 = wxString_in_helper(obj3);
17158 if (arg4 == NULL) SWIG_fail;
17159 temp4 = true;
17160 }
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 resultobj = SWIG_Py_Void();
17168 {
17169 if (temp4)
17170 delete arg4;
17171 }
17172 return resultobj;
17173 fail:
17174 {
17175 if (temp4)
17176 delete arg4;
17177 }
17178 return NULL;
17179 }
17180
17181
17182 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj = 0;
17184 wxGrid *arg1 = (wxGrid *) 0 ;
17185 int arg2 ;
17186 int arg3 ;
17187 bool result;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 int val2 ;
17191 int ecode2 = 0 ;
17192 int val3 ;
17193 int ecode3 = 0 ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 PyObject * obj2 = 0 ;
17197 char * kwnames[] = {
17198 (char *) "self",(char *) "row",(char *) "col", NULL
17199 };
17200
17201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17203 if (!SWIG_IsOK(res1)) {
17204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17205 }
17206 arg1 = reinterpret_cast< wxGrid * >(argp1);
17207 ecode2 = SWIG_AsVal_int(obj1, &val2);
17208 if (!SWIG_IsOK(ecode2)) {
17209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17210 }
17211 arg2 = static_cast< int >(val2);
17212 ecode3 = SWIG_AsVal_int(obj2, &val3);
17213 if (!SWIG_IsOK(ecode3)) {
17214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17215 }
17216 arg3 = static_cast< int >(val3);
17217 {
17218 PyThreadState* __tstate = wxPyBeginAllowThreads();
17219 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 {
17224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17225 }
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj = 0;
17234 wxGrid *arg1 = (wxGrid *) 0 ;
17235 int arg2 ;
17236 int arg3 ;
17237 bool arg4 = (bool) true ;
17238 void *argp1 = 0 ;
17239 int res1 = 0 ;
17240 int val2 ;
17241 int ecode2 = 0 ;
17242 int val3 ;
17243 int ecode3 = 0 ;
17244 bool val4 ;
17245 int ecode4 = 0 ;
17246 PyObject * obj0 = 0 ;
17247 PyObject * obj1 = 0 ;
17248 PyObject * obj2 = 0 ;
17249 PyObject * obj3 = 0 ;
17250 char * kwnames[] = {
17251 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17252 };
17253
17254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17256 if (!SWIG_IsOK(res1)) {
17257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17258 }
17259 arg1 = reinterpret_cast< wxGrid * >(argp1);
17260 ecode2 = SWIG_AsVal_int(obj1, &val2);
17261 if (!SWIG_IsOK(ecode2)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17263 }
17264 arg2 = static_cast< int >(val2);
17265 ecode3 = SWIG_AsVal_int(obj2, &val3);
17266 if (!SWIG_IsOK(ecode3)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17268 }
17269 arg3 = static_cast< int >(val3);
17270 if (obj3) {
17271 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17272 if (!SWIG_IsOK(ecode4)) {
17273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17274 }
17275 arg4 = static_cast< bool >(val4);
17276 }
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 (arg1)->SetReadOnly(arg2,arg3,arg4);
17280 wxPyEndAllowThreads(__tstate);
17281 if (PyErr_Occurred()) SWIG_fail;
17282 }
17283 resultobj = SWIG_Py_Void();
17284 return resultobj;
17285 fail:
17286 return NULL;
17287 }
17288
17289
17290 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17291 PyObject *resultobj = 0;
17292 wxGrid *arg1 = (wxGrid *) 0 ;
17293 int arg2 ;
17294 bool arg3 = (bool) false ;
17295 void *argp1 = 0 ;
17296 int res1 = 0 ;
17297 int val2 ;
17298 int ecode2 = 0 ;
17299 bool val3 ;
17300 int ecode3 = 0 ;
17301 PyObject * obj0 = 0 ;
17302 PyObject * obj1 = 0 ;
17303 PyObject * obj2 = 0 ;
17304 char * kwnames[] = {
17305 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17306 };
17307
17308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17310 if (!SWIG_IsOK(res1)) {
17311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17312 }
17313 arg1 = reinterpret_cast< wxGrid * >(argp1);
17314 ecode2 = SWIG_AsVal_int(obj1, &val2);
17315 if (!SWIG_IsOK(ecode2)) {
17316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17317 }
17318 arg2 = static_cast< int >(val2);
17319 if (obj2) {
17320 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17321 if (!SWIG_IsOK(ecode3)) {
17322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17323 }
17324 arg3 = static_cast< bool >(val3);
17325 }
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 (arg1)->SelectRow(arg2,arg3);
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 resultobj = SWIG_Py_Void();
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj = 0;
17341 wxGrid *arg1 = (wxGrid *) 0 ;
17342 int arg2 ;
17343 bool arg3 = (bool) false ;
17344 void *argp1 = 0 ;
17345 int res1 = 0 ;
17346 int val2 ;
17347 int ecode2 = 0 ;
17348 bool val3 ;
17349 int ecode3 = 0 ;
17350 PyObject * obj0 = 0 ;
17351 PyObject * obj1 = 0 ;
17352 PyObject * obj2 = 0 ;
17353 char * kwnames[] = {
17354 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17355 };
17356
17357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17359 if (!SWIG_IsOK(res1)) {
17360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17361 }
17362 arg1 = reinterpret_cast< wxGrid * >(argp1);
17363 ecode2 = SWIG_AsVal_int(obj1, &val2);
17364 if (!SWIG_IsOK(ecode2)) {
17365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17366 }
17367 arg2 = static_cast< int >(val2);
17368 if (obj2) {
17369 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17370 if (!SWIG_IsOK(ecode3)) {
17371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17372 }
17373 arg3 = static_cast< bool >(val3);
17374 }
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 (arg1)->SelectCol(arg2,arg3);
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 resultobj = SWIG_Py_Void();
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxGrid *arg1 = (wxGrid *) 0 ;
17391 int arg2 ;
17392 int arg3 ;
17393 int arg4 ;
17394 int arg5 ;
17395 bool arg6 = (bool) false ;
17396 void *argp1 = 0 ;
17397 int res1 = 0 ;
17398 int val2 ;
17399 int ecode2 = 0 ;
17400 int val3 ;
17401 int ecode3 = 0 ;
17402 int val4 ;
17403 int ecode4 = 0 ;
17404 int val5 ;
17405 int ecode5 = 0 ;
17406 bool val6 ;
17407 int ecode6 = 0 ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 PyObject * obj3 = 0 ;
17412 PyObject * obj4 = 0 ;
17413 PyObject * obj5 = 0 ;
17414 char * kwnames[] = {
17415 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17416 };
17417
17418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17420 if (!SWIG_IsOK(res1)) {
17421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17422 }
17423 arg1 = reinterpret_cast< wxGrid * >(argp1);
17424 ecode2 = SWIG_AsVal_int(obj1, &val2);
17425 if (!SWIG_IsOK(ecode2)) {
17426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17427 }
17428 arg2 = static_cast< int >(val2);
17429 ecode3 = SWIG_AsVal_int(obj2, &val3);
17430 if (!SWIG_IsOK(ecode3)) {
17431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17432 }
17433 arg3 = static_cast< int >(val3);
17434 ecode4 = SWIG_AsVal_int(obj3, &val4);
17435 if (!SWIG_IsOK(ecode4)) {
17436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17437 }
17438 arg4 = static_cast< int >(val4);
17439 ecode5 = SWIG_AsVal_int(obj4, &val5);
17440 if (!SWIG_IsOK(ecode5)) {
17441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17442 }
17443 arg5 = static_cast< int >(val5);
17444 if (obj5) {
17445 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17446 if (!SWIG_IsOK(ecode6)) {
17447 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17448 }
17449 arg6 = static_cast< bool >(val6);
17450 }
17451 {
17452 PyThreadState* __tstate = wxPyBeginAllowThreads();
17453 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 resultobj = SWIG_Py_Void();
17458 return resultobj;
17459 fail:
17460 return NULL;
17461 }
17462
17463
17464 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 PyObject *resultobj = 0;
17466 wxGrid *arg1 = (wxGrid *) 0 ;
17467 void *argp1 = 0 ;
17468 int res1 = 0 ;
17469 PyObject *swig_obj[1] ;
17470
17471 if (!args) SWIG_fail;
17472 swig_obj[0] = args;
17473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17474 if (!SWIG_IsOK(res1)) {
17475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17476 }
17477 arg1 = reinterpret_cast< wxGrid * >(argp1);
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 (arg1)->SelectAll();
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 resultobj = SWIG_Py_Void();
17485 return resultobj;
17486 fail:
17487 return NULL;
17488 }
17489
17490
17491 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *resultobj = 0;
17493 wxGrid *arg1 = (wxGrid *) 0 ;
17494 bool result;
17495 void *argp1 = 0 ;
17496 int res1 = 0 ;
17497 PyObject *swig_obj[1] ;
17498
17499 if (!args) SWIG_fail;
17500 swig_obj[0] = args;
17501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17502 if (!SWIG_IsOK(res1)) {
17503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17504 }
17505 arg1 = reinterpret_cast< wxGrid * >(argp1);
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (bool)(arg1)->IsSelection();
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 {
17513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17514 }
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 PyObject *resultobj = 0;
17523 wxGrid *arg1 = (wxGrid *) 0 ;
17524 void *argp1 = 0 ;
17525 int res1 = 0 ;
17526 PyObject *swig_obj[1] ;
17527
17528 if (!args) SWIG_fail;
17529 swig_obj[0] = args;
17530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17531 if (!SWIG_IsOK(res1)) {
17532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17533 }
17534 arg1 = reinterpret_cast< wxGrid * >(argp1);
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 (arg1)->ClearSelection();
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 resultobj = SWIG_Py_Void();
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj = 0;
17550 wxGrid *arg1 = (wxGrid *) 0 ;
17551 int arg2 ;
17552 int arg3 ;
17553 bool result;
17554 void *argp1 = 0 ;
17555 int res1 = 0 ;
17556 int val2 ;
17557 int ecode2 = 0 ;
17558 int val3 ;
17559 int ecode3 = 0 ;
17560 PyObject * obj0 = 0 ;
17561 PyObject * obj1 = 0 ;
17562 PyObject * obj2 = 0 ;
17563 char * kwnames[] = {
17564 (char *) "self",(char *) "row",(char *) "col", NULL
17565 };
17566
17567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17569 if (!SWIG_IsOK(res1)) {
17570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17571 }
17572 arg1 = reinterpret_cast< wxGrid * >(argp1);
17573 ecode2 = SWIG_AsVal_int(obj1, &val2);
17574 if (!SWIG_IsOK(ecode2)) {
17575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17576 }
17577 arg2 = static_cast< int >(val2);
17578 ecode3 = SWIG_AsVal_int(obj2, &val3);
17579 if (!SWIG_IsOK(ecode3)) {
17580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17581 }
17582 arg3 = static_cast< int >(val3);
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 {
17590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17591 }
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 PyObject *resultobj = 0;
17600 wxGrid *arg1 = (wxGrid *) 0 ;
17601 wxGridCellCoordsArray result;
17602 void *argp1 = 0 ;
17603 int res1 = 0 ;
17604 PyObject *swig_obj[1] ;
17605
17606 if (!args) SWIG_fail;
17607 swig_obj[0] = args;
17608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17611 }
17612 arg1 = reinterpret_cast< wxGrid * >(argp1);
17613 {
17614 PyThreadState* __tstate = wxPyBeginAllowThreads();
17615 result = ((wxGrid const *)arg1)->GetSelectedCells();
17616 wxPyEndAllowThreads(__tstate);
17617 if (PyErr_Occurred()) SWIG_fail;
17618 }
17619 {
17620 resultobj = wxGridCellCoordsArray_helper(result);
17621 }
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17629 PyObject *resultobj = 0;
17630 wxGrid *arg1 = (wxGrid *) 0 ;
17631 wxGridCellCoordsArray result;
17632 void *argp1 = 0 ;
17633 int res1 = 0 ;
17634 PyObject *swig_obj[1] ;
17635
17636 if (!args) SWIG_fail;
17637 swig_obj[0] = args;
17638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17639 if (!SWIG_IsOK(res1)) {
17640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17641 }
17642 arg1 = reinterpret_cast< wxGrid * >(argp1);
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 resultobj = wxGridCellCoordsArray_helper(result);
17651 }
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17659 PyObject *resultobj = 0;
17660 wxGrid *arg1 = (wxGrid *) 0 ;
17661 wxGridCellCoordsArray result;
17662 void *argp1 = 0 ;
17663 int res1 = 0 ;
17664 PyObject *swig_obj[1] ;
17665
17666 if (!args) SWIG_fail;
17667 swig_obj[0] = args;
17668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17671 }
17672 arg1 = reinterpret_cast< wxGrid * >(argp1);
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17676 wxPyEndAllowThreads(__tstate);
17677 if (PyErr_Occurred()) SWIG_fail;
17678 }
17679 {
17680 resultobj = wxGridCellCoordsArray_helper(result);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxGrid *arg1 = (wxGrid *) 0 ;
17691 wxArrayInt result;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 PyObject *swig_obj[1] ;
17695
17696 if (!args) SWIG_fail;
17697 swig_obj[0] = args;
17698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17701 }
17702 arg1 = reinterpret_cast< wxGrid * >(argp1);
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 result = ((wxGrid const *)arg1)->GetSelectedRows();
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = PyList_New(0);
17711 size_t idx;
17712 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17713 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17714 PyList_Append(resultobj, val);
17715 Py_DECREF(val);
17716 }
17717 }
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17725 PyObject *resultobj = 0;
17726 wxGrid *arg1 = (wxGrid *) 0 ;
17727 wxArrayInt result;
17728 void *argp1 = 0 ;
17729 int res1 = 0 ;
17730 PyObject *swig_obj[1] ;
17731
17732 if (!args) SWIG_fail;
17733 swig_obj[0] = args;
17734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17735 if (!SWIG_IsOK(res1)) {
17736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17737 }
17738 arg1 = reinterpret_cast< wxGrid * >(argp1);
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 result = ((wxGrid const *)arg1)->GetSelectedCols();
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 {
17746 resultobj = PyList_New(0);
17747 size_t idx;
17748 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17749 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17750 PyList_Append(resultobj, val);
17751 Py_DECREF(val);
17752 }
17753 }
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = 0;
17762 wxGrid *arg1 = (wxGrid *) 0 ;
17763 int arg2 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 int val2 ;
17767 int ecode2 = 0 ;
17768 PyObject * obj0 = 0 ;
17769 PyObject * obj1 = 0 ;
17770 char * kwnames[] = {
17771 (char *) "self",(char *) "row", NULL
17772 };
17773
17774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17776 if (!SWIG_IsOK(res1)) {
17777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17778 }
17779 arg1 = reinterpret_cast< wxGrid * >(argp1);
17780 ecode2 = SWIG_AsVal_int(obj1, &val2);
17781 if (!SWIG_IsOK(ecode2)) {
17782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17783 }
17784 arg2 = static_cast< int >(val2);
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 (arg1)->DeselectRow(arg2);
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_Py_Void();
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj = 0;
17800 wxGrid *arg1 = (wxGrid *) 0 ;
17801 int arg2 ;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 int val2 ;
17805 int ecode2 = 0 ;
17806 PyObject * obj0 = 0 ;
17807 PyObject * obj1 = 0 ;
17808 char * kwnames[] = {
17809 (char *) "self",(char *) "col", NULL
17810 };
17811
17812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17814 if (!SWIG_IsOK(res1)) {
17815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17816 }
17817 arg1 = reinterpret_cast< wxGrid * >(argp1);
17818 ecode2 = SWIG_AsVal_int(obj1, &val2);
17819 if (!SWIG_IsOK(ecode2)) {
17820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17821 }
17822 arg2 = static_cast< int >(val2);
17823 {
17824 PyThreadState* __tstate = wxPyBeginAllowThreads();
17825 (arg1)->DeselectCol(arg2);
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 resultobj = SWIG_Py_Void();
17830 return resultobj;
17831 fail:
17832 return NULL;
17833 }
17834
17835
17836 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17837 PyObject *resultobj = 0;
17838 wxGrid *arg1 = (wxGrid *) 0 ;
17839 int arg2 ;
17840 int arg3 ;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 int val2 ;
17844 int ecode2 = 0 ;
17845 int val3 ;
17846 int ecode3 = 0 ;
17847 PyObject * obj0 = 0 ;
17848 PyObject * obj1 = 0 ;
17849 PyObject * obj2 = 0 ;
17850 char * kwnames[] = {
17851 (char *) "self",(char *) "row",(char *) "col", NULL
17852 };
17853
17854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17858 }
17859 arg1 = reinterpret_cast< wxGrid * >(argp1);
17860 ecode2 = SWIG_AsVal_int(obj1, &val2);
17861 if (!SWIG_IsOK(ecode2)) {
17862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17863 }
17864 arg2 = static_cast< int >(val2);
17865 ecode3 = SWIG_AsVal_int(obj2, &val3);
17866 if (!SWIG_IsOK(ecode3)) {
17867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17868 }
17869 arg3 = static_cast< int >(val3);
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 (arg1)->DeselectCell(arg2,arg3);
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 resultobj = SWIG_Py_Void();
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj = 0;
17885 wxGrid *arg1 = (wxGrid *) 0 ;
17886 wxGridCellCoords *arg2 = 0 ;
17887 wxGridCellCoords *arg3 = 0 ;
17888 wxRect result;
17889 void *argp1 = 0 ;
17890 int res1 = 0 ;
17891 wxGridCellCoords temp2 ;
17892 wxGridCellCoords temp3 ;
17893 PyObject * obj0 = 0 ;
17894 PyObject * obj1 = 0 ;
17895 PyObject * obj2 = 0 ;
17896 char * kwnames[] = {
17897 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17898 };
17899
17900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17902 if (!SWIG_IsOK(res1)) {
17903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17904 }
17905 arg1 = reinterpret_cast< wxGrid * >(argp1);
17906 {
17907 arg2 = &temp2;
17908 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17909 }
17910 {
17911 arg3 = &temp3;
17912 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17913 }
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17928 PyObject *resultobj = 0;
17929 wxGrid *arg1 = (wxGrid *) 0 ;
17930 wxColour result;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 PyObject *swig_obj[1] ;
17934
17935 if (!args) SWIG_fail;
17936 swig_obj[0] = args;
17937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17938 if (!SWIG_IsOK(res1)) {
17939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17940 }
17941 arg1 = reinterpret_cast< wxGrid * >(argp1);
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17956 PyObject *resultobj = 0;
17957 wxGrid *arg1 = (wxGrid *) 0 ;
17958 wxColour result;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 PyObject *swig_obj[1] ;
17962
17963 if (!args) SWIG_fail;
17964 swig_obj[0] = args;
17965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17968 }
17969 arg1 = reinterpret_cast< wxGrid * >(argp1);
17970 {
17971 PyThreadState* __tstate = wxPyBeginAllowThreads();
17972 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17977 return resultobj;
17978 fail:
17979 return NULL;
17980 }
17981
17982
17983 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17984 PyObject *resultobj = 0;
17985 wxGrid *arg1 = (wxGrid *) 0 ;
17986 wxColour *arg2 = 0 ;
17987 void *argp1 = 0 ;
17988 int res1 = 0 ;
17989 wxColour temp2 ;
17990 PyObject * obj0 = 0 ;
17991 PyObject * obj1 = 0 ;
17992 char * kwnames[] = {
17993 (char *) "self",(char *) "c", NULL
17994 };
17995
17996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17998 if (!SWIG_IsOK(res1)) {
17999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18000 }
18001 arg1 = reinterpret_cast< wxGrid * >(argp1);
18002 {
18003 arg2 = &temp2;
18004 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18005 }
18006 {
18007 PyThreadState* __tstate = wxPyBeginAllowThreads();
18008 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 resultobj = SWIG_Py_Void();
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj = 0;
18021 wxGrid *arg1 = (wxGrid *) 0 ;
18022 wxColour *arg2 = 0 ;
18023 void *argp1 = 0 ;
18024 int res1 = 0 ;
18025 wxColour temp2 ;
18026 PyObject * obj0 = 0 ;
18027 PyObject * obj1 = 0 ;
18028 char * kwnames[] = {
18029 (char *) "self",(char *) "c", NULL
18030 };
18031
18032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18034 if (!SWIG_IsOK(res1)) {
18035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18036 }
18037 arg1 = reinterpret_cast< wxGrid * >(argp1);
18038 {
18039 arg2 = &temp2;
18040 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18041 }
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 resultobj = SWIG_Py_Void();
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18056 PyObject *resultobj = 0;
18057 wxGrid *arg1 = (wxGrid *) 0 ;
18058 wxString *arg2 = 0 ;
18059 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18060 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18061 void *argp1 = 0 ;
18062 int res1 = 0 ;
18063 bool temp2 = false ;
18064 void *argp3 = 0 ;
18065 int res3 = 0 ;
18066 void *argp4 = 0 ;
18067 int res4 = 0 ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 PyObject * obj2 = 0 ;
18071 PyObject * obj3 = 0 ;
18072 char * kwnames[] = {
18073 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18074 };
18075
18076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18078 if (!SWIG_IsOK(res1)) {
18079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18080 }
18081 arg1 = reinterpret_cast< wxGrid * >(argp1);
18082 {
18083 arg2 = wxString_in_helper(obj1);
18084 if (arg2 == NULL) SWIG_fail;
18085 temp2 = true;
18086 }
18087 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18088 if (!SWIG_IsOK(res3)) {
18089 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18090 }
18091 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18092 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18093 if (!SWIG_IsOK(res4)) {
18094 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18095 }
18096 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18097 {
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 resultobj = SWIG_Py_Void();
18104 {
18105 if (temp2)
18106 delete arg2;
18107 }
18108 return resultobj;
18109 fail:
18110 {
18111 if (temp2)
18112 delete arg2;
18113 }
18114 return NULL;
18115 }
18116
18117
18118 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj = 0;
18120 wxGrid *arg1 = (wxGrid *) 0 ;
18121 int arg2 ;
18122 int arg3 ;
18123 wxGridCellEditor *result = 0 ;
18124 void *argp1 = 0 ;
18125 int res1 = 0 ;
18126 int val2 ;
18127 int ecode2 = 0 ;
18128 int val3 ;
18129 int ecode3 = 0 ;
18130 PyObject * obj0 = 0 ;
18131 PyObject * obj1 = 0 ;
18132 PyObject * obj2 = 0 ;
18133 char * kwnames[] = {
18134 (char *) "self",(char *) "row",(char *) "col", NULL
18135 };
18136
18137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18139 if (!SWIG_IsOK(res1)) {
18140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18141 }
18142 arg1 = reinterpret_cast< wxGrid * >(argp1);
18143 ecode2 = SWIG_AsVal_int(obj1, &val2);
18144 if (!SWIG_IsOK(ecode2)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18146 }
18147 arg2 = static_cast< int >(val2);
18148 ecode3 = SWIG_AsVal_int(obj2, &val3);
18149 if (!SWIG_IsOK(ecode3)) {
18150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18151 }
18152 arg3 = static_cast< int >(val3);
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18156 wxPyEndAllowThreads(__tstate);
18157 if (PyErr_Occurred()) SWIG_fail;
18158 }
18159 {
18160 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18161 }
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18169 PyObject *resultobj = 0;
18170 wxGrid *arg1 = (wxGrid *) 0 ;
18171 int arg2 ;
18172 int arg3 ;
18173 wxGridCellRenderer *result = 0 ;
18174 void *argp1 = 0 ;
18175 int res1 = 0 ;
18176 int val2 ;
18177 int ecode2 = 0 ;
18178 int val3 ;
18179 int ecode3 = 0 ;
18180 PyObject * obj0 = 0 ;
18181 PyObject * obj1 = 0 ;
18182 PyObject * obj2 = 0 ;
18183 char * kwnames[] = {
18184 (char *) "self",(char *) "row",(char *) "col", NULL
18185 };
18186
18187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18189 if (!SWIG_IsOK(res1)) {
18190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18191 }
18192 arg1 = reinterpret_cast< wxGrid * >(argp1);
18193 ecode2 = SWIG_AsVal_int(obj1, &val2);
18194 if (!SWIG_IsOK(ecode2)) {
18195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18196 }
18197 arg2 = static_cast< int >(val2);
18198 ecode3 = SWIG_AsVal_int(obj2, &val3);
18199 if (!SWIG_IsOK(ecode3)) {
18200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18201 }
18202 arg3 = static_cast< int >(val3);
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 {
18210 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18211 }
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj = 0;
18220 wxGrid *arg1 = (wxGrid *) 0 ;
18221 wxString *arg2 = 0 ;
18222 wxGridCellEditor *result = 0 ;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 bool temp2 = false ;
18226 PyObject * obj0 = 0 ;
18227 PyObject * obj1 = 0 ;
18228 char * kwnames[] = {
18229 (char *) "self",(char *) "typeName", NULL
18230 };
18231
18232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18234 if (!SWIG_IsOK(res1)) {
18235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18236 }
18237 arg1 = reinterpret_cast< wxGrid * >(argp1);
18238 {
18239 arg2 = wxString_in_helper(obj1);
18240 if (arg2 == NULL) SWIG_fail;
18241 temp2 = true;
18242 }
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 {
18250 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18251 }
18252 {
18253 if (temp2)
18254 delete arg2;
18255 }
18256 return resultobj;
18257 fail:
18258 {
18259 if (temp2)
18260 delete arg2;
18261 }
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj = 0;
18268 wxGrid *arg1 = (wxGrid *) 0 ;
18269 wxString *arg2 = 0 ;
18270 wxGridCellRenderer *result = 0 ;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 bool temp2 = false ;
18274 PyObject * obj0 = 0 ;
18275 PyObject * obj1 = 0 ;
18276 char * kwnames[] = {
18277 (char *) "self",(char *) "typeName", NULL
18278 };
18279
18280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18282 if (!SWIG_IsOK(res1)) {
18283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18284 }
18285 arg1 = reinterpret_cast< wxGrid * >(argp1);
18286 {
18287 arg2 = wxString_in_helper(obj1);
18288 if (arg2 == NULL) SWIG_fail;
18289 temp2 = true;
18290 }
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 {
18298 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18299 }
18300 {
18301 if (temp2)
18302 delete arg2;
18303 }
18304 return resultobj;
18305 fail:
18306 {
18307 if (temp2)
18308 delete arg2;
18309 }
18310 return NULL;
18311 }
18312
18313
18314 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj = 0;
18316 wxGrid *arg1 = (wxGrid *) 0 ;
18317 int arg2 ;
18318 int arg3 ;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 int val2 ;
18322 int ecode2 = 0 ;
18323 int val3 ;
18324 int ecode3 = 0 ;
18325 PyObject * obj0 = 0 ;
18326 PyObject * obj1 = 0 ;
18327 PyObject * obj2 = 0 ;
18328 char * kwnames[] = {
18329 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18330 };
18331
18332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18334 if (!SWIG_IsOK(res1)) {
18335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18336 }
18337 arg1 = reinterpret_cast< wxGrid * >(argp1);
18338 ecode2 = SWIG_AsVal_int(obj1, &val2);
18339 if (!SWIG_IsOK(ecode2)) {
18340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18341 }
18342 arg2 = static_cast< int >(val2);
18343 ecode3 = SWIG_AsVal_int(obj2, &val3);
18344 if (!SWIG_IsOK(ecode3)) {
18345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18346 }
18347 arg3 = static_cast< int >(val3);
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 (arg1)->SetMargins(arg2,arg3);
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = SWIG_Py_Void();
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18362 PyObject *resultobj = 0;
18363 wxGrid *arg1 = (wxGrid *) 0 ;
18364 wxWindow *result = 0 ;
18365 void *argp1 = 0 ;
18366 int res1 = 0 ;
18367 PyObject *swig_obj[1] ;
18368
18369 if (!args) SWIG_fail;
18370 swig_obj[0] = args;
18371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18372 if (!SWIG_IsOK(res1)) {
18373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18374 }
18375 arg1 = reinterpret_cast< wxGrid * >(argp1);
18376 {
18377 PyThreadState* __tstate = wxPyBeginAllowThreads();
18378 result = (wxWindow *)(arg1)->GetGridWindow();
18379 wxPyEndAllowThreads(__tstate);
18380 if (PyErr_Occurred()) SWIG_fail;
18381 }
18382 {
18383 resultobj = wxPyMake_wxObject(result, 0);
18384 }
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18392 PyObject *resultobj = 0;
18393 wxGrid *arg1 = (wxGrid *) 0 ;
18394 wxWindow *result = 0 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 PyObject *swig_obj[1] ;
18398
18399 if (!args) SWIG_fail;
18400 swig_obj[0] = args;
18401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18402 if (!SWIG_IsOK(res1)) {
18403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18404 }
18405 arg1 = reinterpret_cast< wxGrid * >(argp1);
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 {
18413 resultobj = wxPyMake_wxObject(result, 0);
18414 }
18415 return resultobj;
18416 fail:
18417 return NULL;
18418 }
18419
18420
18421 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18422 PyObject *resultobj = 0;
18423 wxGrid *arg1 = (wxGrid *) 0 ;
18424 wxWindow *result = 0 ;
18425 void *argp1 = 0 ;
18426 int res1 = 0 ;
18427 PyObject *swig_obj[1] ;
18428
18429 if (!args) SWIG_fail;
18430 swig_obj[0] = args;
18431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18432 if (!SWIG_IsOK(res1)) {
18433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18434 }
18435 arg1 = reinterpret_cast< wxGrid * >(argp1);
18436 {
18437 PyThreadState* __tstate = wxPyBeginAllowThreads();
18438 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18439 wxPyEndAllowThreads(__tstate);
18440 if (PyErr_Occurred()) SWIG_fail;
18441 }
18442 {
18443 resultobj = wxPyMake_wxObject(result, 0);
18444 }
18445 return resultobj;
18446 fail:
18447 return NULL;
18448 }
18449
18450
18451 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18452 PyObject *resultobj = 0;
18453 wxGrid *arg1 = (wxGrid *) 0 ;
18454 wxWindow *result = 0 ;
18455 void *argp1 = 0 ;
18456 int res1 = 0 ;
18457 PyObject *swig_obj[1] ;
18458
18459 if (!args) SWIG_fail;
18460 swig_obj[0] = args;
18461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18462 if (!SWIG_IsOK(res1)) {
18463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18464 }
18465 arg1 = reinterpret_cast< wxGrid * >(argp1);
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 {
18473 resultobj = wxPyMake_wxObject(result, 0);
18474 }
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18482 PyObject *resultobj = 0;
18483 wxGrid *arg1 = (wxGrid *) 0 ;
18484 int arg2 ;
18485 void *argp1 = 0 ;
18486 int res1 = 0 ;
18487 int val2 ;
18488 int ecode2 = 0 ;
18489 PyObject * obj0 = 0 ;
18490 PyObject * obj1 = 0 ;
18491 char * kwnames[] = {
18492 (char *) "self",(char *) "x", NULL
18493 };
18494
18495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18497 if (!SWIG_IsOK(res1)) {
18498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18499 }
18500 arg1 = reinterpret_cast< wxGrid * >(argp1);
18501 ecode2 = SWIG_AsVal_int(obj1, &val2);
18502 if (!SWIG_IsOK(ecode2)) {
18503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18504 }
18505 arg2 = static_cast< int >(val2);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 (arg1)->SetScrollLineX(arg2);
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 resultobj = SWIG_Py_Void();
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18520 PyObject *resultobj = 0;
18521 wxGrid *arg1 = (wxGrid *) 0 ;
18522 int arg2 ;
18523 void *argp1 = 0 ;
18524 int res1 = 0 ;
18525 int val2 ;
18526 int ecode2 = 0 ;
18527 PyObject * obj0 = 0 ;
18528 PyObject * obj1 = 0 ;
18529 char * kwnames[] = {
18530 (char *) "self",(char *) "y", NULL
18531 };
18532
18533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18535 if (!SWIG_IsOK(res1)) {
18536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18537 }
18538 arg1 = reinterpret_cast< wxGrid * >(argp1);
18539 ecode2 = SWIG_AsVal_int(obj1, &val2);
18540 if (!SWIG_IsOK(ecode2)) {
18541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18542 }
18543 arg2 = static_cast< int >(val2);
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 (arg1)->SetScrollLineY(arg2);
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 resultobj = SWIG_Py_Void();
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18558 PyObject *resultobj = 0;
18559 wxGrid *arg1 = (wxGrid *) 0 ;
18560 int result;
18561 void *argp1 = 0 ;
18562 int res1 = 0 ;
18563 PyObject *swig_obj[1] ;
18564
18565 if (!args) SWIG_fail;
18566 swig_obj[0] = args;
18567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18568 if (!SWIG_IsOK(res1)) {
18569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18570 }
18571 arg1 = reinterpret_cast< wxGrid * >(argp1);
18572 {
18573 PyThreadState* __tstate = wxPyBeginAllowThreads();
18574 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18575 wxPyEndAllowThreads(__tstate);
18576 if (PyErr_Occurred()) SWIG_fail;
18577 }
18578 resultobj = SWIG_From_int(static_cast< int >(result));
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18586 PyObject *resultobj = 0;
18587 wxGrid *arg1 = (wxGrid *) 0 ;
18588 int result;
18589 void *argp1 = 0 ;
18590 int res1 = 0 ;
18591 PyObject *swig_obj[1] ;
18592
18593 if (!args) SWIG_fail;
18594 swig_obj[0] = args;
18595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18596 if (!SWIG_IsOK(res1)) {
18597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18598 }
18599 arg1 = reinterpret_cast< wxGrid * >(argp1);
18600 {
18601 PyThreadState* __tstate = wxPyBeginAllowThreads();
18602 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18603 wxPyEndAllowThreads(__tstate);
18604 if (PyErr_Occurred()) SWIG_fail;
18605 }
18606 resultobj = SWIG_From_int(static_cast< int >(result));
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj = 0;
18615 wxGrid *arg1 = (wxGrid *) 0 ;
18616 int arg2 ;
18617 int result;
18618 void *argp1 = 0 ;
18619 int res1 = 0 ;
18620 int val2 ;
18621 int ecode2 = 0 ;
18622 PyObject * obj0 = 0 ;
18623 PyObject * obj1 = 0 ;
18624 char * kwnames[] = {
18625 (char *) "self",(char *) "x", NULL
18626 };
18627
18628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18630 if (!SWIG_IsOK(res1)) {
18631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18632 }
18633 arg1 = reinterpret_cast< wxGrid * >(argp1);
18634 ecode2 = SWIG_AsVal_int(obj1, &val2);
18635 if (!SWIG_IsOK(ecode2)) {
18636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18637 }
18638 arg2 = static_cast< int >(val2);
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 resultobj = SWIG_From_int(static_cast< int >(result));
18646 return resultobj;
18647 fail:
18648 return NULL;
18649 }
18650
18651
18652 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18653 PyObject *resultobj = 0;
18654 wxGrid *arg1 = (wxGrid *) 0 ;
18655 int arg2 ;
18656 int result;
18657 void *argp1 = 0 ;
18658 int res1 = 0 ;
18659 int val2 ;
18660 int ecode2 = 0 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char * kwnames[] = {
18664 (char *) "self",(char *) "y", NULL
18665 };
18666
18667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18669 if (!SWIG_IsOK(res1)) {
18670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18671 }
18672 arg1 = reinterpret_cast< wxGrid * >(argp1);
18673 ecode2 = SWIG_AsVal_int(obj1, &val2);
18674 if (!SWIG_IsOK(ecode2)) {
18675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18676 }
18677 arg2 = static_cast< int >(val2);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 resultobj = SWIG_From_int(static_cast< int >(result));
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj = 0;
18693 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18694 SwigValueWrapper<wxVisualAttributes > result;
18695 int val1 ;
18696 int ecode1 = 0 ;
18697 PyObject * obj0 = 0 ;
18698 char * kwnames[] = {
18699 (char *) "variant", NULL
18700 };
18701
18702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18703 if (obj0) {
18704 ecode1 = SWIG_AsVal_int(obj0, &val1);
18705 if (!SWIG_IsOK(ecode1)) {
18706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18707 }
18708 arg1 = static_cast< wxWindowVariant >(val1);
18709 }
18710 {
18711 if (!wxPyCheckForApp()) SWIG_fail;
18712 PyThreadState* __tstate = wxPyBeginAllowThreads();
18713 result = wxGrid::GetClassDefaultAttributes(arg1);
18714 wxPyEndAllowThreads(__tstate);
18715 if (PyErr_Occurred()) SWIG_fail;
18716 }
18717 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18725 PyObject *obj;
18726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18727 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18728 return SWIG_Py_Void();
18729 }
18730
18731 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18732 return SWIG_Python_InitShadowInstance(args);
18733 }
18734
18735 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj = 0;
18737 int arg1 ;
18738 wxEventType arg2 ;
18739 wxGrid *arg3 = (wxGrid *) 0 ;
18740 int arg4 = (int) -1 ;
18741 int arg5 = (int) -1 ;
18742 int arg6 = (int) -1 ;
18743 int arg7 = (int) -1 ;
18744 bool arg8 = (bool) true ;
18745 bool arg9 = (bool) false ;
18746 bool arg10 = (bool) false ;
18747 bool arg11 = (bool) false ;
18748 bool arg12 = (bool) false ;
18749 wxGridEvent *result = 0 ;
18750 int val1 ;
18751 int ecode1 = 0 ;
18752 int val2 ;
18753 int ecode2 = 0 ;
18754 void *argp3 = 0 ;
18755 int res3 = 0 ;
18756 int val4 ;
18757 int ecode4 = 0 ;
18758 int val5 ;
18759 int ecode5 = 0 ;
18760 int val6 ;
18761 int ecode6 = 0 ;
18762 int val7 ;
18763 int ecode7 = 0 ;
18764 bool val8 ;
18765 int ecode8 = 0 ;
18766 bool val9 ;
18767 int ecode9 = 0 ;
18768 bool val10 ;
18769 int ecode10 = 0 ;
18770 bool val11 ;
18771 int ecode11 = 0 ;
18772 bool val12 ;
18773 int ecode12 = 0 ;
18774 PyObject * obj0 = 0 ;
18775 PyObject * obj1 = 0 ;
18776 PyObject * obj2 = 0 ;
18777 PyObject * obj3 = 0 ;
18778 PyObject * obj4 = 0 ;
18779 PyObject * obj5 = 0 ;
18780 PyObject * obj6 = 0 ;
18781 PyObject * obj7 = 0 ;
18782 PyObject * obj8 = 0 ;
18783 PyObject * obj9 = 0 ;
18784 PyObject * obj10 = 0 ;
18785 PyObject * obj11 = 0 ;
18786 char * kwnames[] = {
18787 (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
18788 };
18789
18790 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;
18791 ecode1 = SWIG_AsVal_int(obj0, &val1);
18792 if (!SWIG_IsOK(ecode1)) {
18793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18794 }
18795 arg1 = static_cast< int >(val1);
18796 ecode2 = SWIG_AsVal_int(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18799 }
18800 arg2 = static_cast< wxEventType >(val2);
18801 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18802 if (!SWIG_IsOK(res3)) {
18803 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18804 }
18805 arg3 = reinterpret_cast< wxGrid * >(argp3);
18806 if (obj3) {
18807 ecode4 = SWIG_AsVal_int(obj3, &val4);
18808 if (!SWIG_IsOK(ecode4)) {
18809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18810 }
18811 arg4 = static_cast< int >(val4);
18812 }
18813 if (obj4) {
18814 ecode5 = SWIG_AsVal_int(obj4, &val5);
18815 if (!SWIG_IsOK(ecode5)) {
18816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18817 }
18818 arg5 = static_cast< int >(val5);
18819 }
18820 if (obj5) {
18821 ecode6 = SWIG_AsVal_int(obj5, &val6);
18822 if (!SWIG_IsOK(ecode6)) {
18823 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18824 }
18825 arg6 = static_cast< int >(val6);
18826 }
18827 if (obj6) {
18828 ecode7 = SWIG_AsVal_int(obj6, &val7);
18829 if (!SWIG_IsOK(ecode7)) {
18830 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18831 }
18832 arg7 = static_cast< int >(val7);
18833 }
18834 if (obj7) {
18835 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18836 if (!SWIG_IsOK(ecode8)) {
18837 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18838 }
18839 arg8 = static_cast< bool >(val8);
18840 }
18841 if (obj8) {
18842 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18843 if (!SWIG_IsOK(ecode9)) {
18844 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18845 }
18846 arg9 = static_cast< bool >(val9);
18847 }
18848 if (obj9) {
18849 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18850 if (!SWIG_IsOK(ecode10)) {
18851 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18852 }
18853 arg10 = static_cast< bool >(val10);
18854 }
18855 if (obj10) {
18856 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18857 if (!SWIG_IsOK(ecode11)) {
18858 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18859 }
18860 arg11 = static_cast< bool >(val11);
18861 }
18862 if (obj11) {
18863 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18864 if (!SWIG_IsOK(ecode12)) {
18865 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18866 }
18867 arg12 = static_cast< bool >(val12);
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 PyObject *resultobj = 0;
18884 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18885 int result;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 PyObject *swig_obj[1] ;
18889
18890 if (!args) SWIG_fail;
18891 swig_obj[0] = args;
18892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18893 if (!SWIG_IsOK(res1)) {
18894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18895 }
18896 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = (int)(arg1)->GetRow();
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_From_int(static_cast< int >(result));
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18911 PyObject *resultobj = 0;
18912 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18913 int result;
18914 void *argp1 = 0 ;
18915 int res1 = 0 ;
18916 PyObject *swig_obj[1] ;
18917
18918 if (!args) SWIG_fail;
18919 swig_obj[0] = args;
18920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18921 if (!SWIG_IsOK(res1)) {
18922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18923 }
18924 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18925 {
18926 PyThreadState* __tstate = wxPyBeginAllowThreads();
18927 result = (int)(arg1)->GetCol();
18928 wxPyEndAllowThreads(__tstate);
18929 if (PyErr_Occurred()) SWIG_fail;
18930 }
18931 resultobj = SWIG_From_int(static_cast< int >(result));
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18939 PyObject *resultobj = 0;
18940 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18941 wxPoint result;
18942 void *argp1 = 0 ;
18943 int res1 = 0 ;
18944 PyObject *swig_obj[1] ;
18945
18946 if (!args) SWIG_fail;
18947 swig_obj[0] = args;
18948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18951 }
18952 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = (arg1)->GetPosition();
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *resultobj = 0;
18968 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18969 bool result;
18970 void *argp1 = 0 ;
18971 int res1 = 0 ;
18972 PyObject *swig_obj[1] ;
18973
18974 if (!args) SWIG_fail;
18975 swig_obj[0] = args;
18976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18977 if (!SWIG_IsOK(res1)) {
18978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18979 }
18980 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 result = (bool)(arg1)->Selecting();
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 {
18988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18989 }
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18997 PyObject *resultobj = 0;
18998 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18999 bool result;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 PyObject *swig_obj[1] ;
19003
19004 if (!args) SWIG_fail;
19005 swig_obj[0] = args;
19006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19007 if (!SWIG_IsOK(res1)) {
19008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19009 }
19010 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 result = (bool)(arg1)->ControlDown();
19014 wxPyEndAllowThreads(__tstate);
19015 if (PyErr_Occurred()) SWIG_fail;
19016 }
19017 {
19018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19019 }
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19027 PyObject *resultobj = 0;
19028 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19029 bool result;
19030 void *argp1 = 0 ;
19031 int res1 = 0 ;
19032 PyObject *swig_obj[1] ;
19033
19034 if (!args) SWIG_fail;
19035 swig_obj[0] = args;
19036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19037 if (!SWIG_IsOK(res1)) {
19038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19039 }
19040 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 result = (bool)(arg1)->MetaDown();
19044 wxPyEndAllowThreads(__tstate);
19045 if (PyErr_Occurred()) SWIG_fail;
19046 }
19047 {
19048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19049 }
19050 return resultobj;
19051 fail:
19052 return NULL;
19053 }
19054
19055
19056 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19057 PyObject *resultobj = 0;
19058 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19059 bool result;
19060 void *argp1 = 0 ;
19061 int res1 = 0 ;
19062 PyObject *swig_obj[1] ;
19063
19064 if (!args) SWIG_fail;
19065 swig_obj[0] = args;
19066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19067 if (!SWIG_IsOK(res1)) {
19068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19069 }
19070 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = (bool)(arg1)->ShiftDown();
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 {
19078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19079 }
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19087 PyObject *resultobj = 0;
19088 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19089 bool result;
19090 void *argp1 = 0 ;
19091 int res1 = 0 ;
19092 PyObject *swig_obj[1] ;
19093
19094 if (!args) SWIG_fail;
19095 swig_obj[0] = args;
19096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19097 if (!SWIG_IsOK(res1)) {
19098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19099 }
19100 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (bool)(arg1)->AltDown();
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 {
19108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19109 }
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117 PyObject *resultobj = 0;
19118 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19119 bool result;
19120 void *argp1 = 0 ;
19121 int res1 = 0 ;
19122 PyObject *swig_obj[1] ;
19123
19124 if (!args) SWIG_fail;
19125 swig_obj[0] = args;
19126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19127 if (!SWIG_IsOK(res1)) {
19128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19129 }
19130 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (bool)(arg1)->CmdDown();
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 {
19138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19139 }
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19147 PyObject *obj;
19148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19149 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19150 return SWIG_Py_Void();
19151 }
19152
19153 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 return SWIG_Python_InitShadowInstance(args);
19155 }
19156
19157 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj = 0;
19159 int arg1 ;
19160 wxEventType arg2 ;
19161 wxGrid *arg3 = (wxGrid *) 0 ;
19162 int arg4 = (int) -1 ;
19163 int arg5 = (int) -1 ;
19164 int arg6 = (int) -1 ;
19165 bool arg7 = (bool) false ;
19166 bool arg8 = (bool) false ;
19167 bool arg9 = (bool) false ;
19168 bool arg10 = (bool) false ;
19169 wxGridSizeEvent *result = 0 ;
19170 int val1 ;
19171 int ecode1 = 0 ;
19172 int val2 ;
19173 int ecode2 = 0 ;
19174 void *argp3 = 0 ;
19175 int res3 = 0 ;
19176 int val4 ;
19177 int ecode4 = 0 ;
19178 int val5 ;
19179 int ecode5 = 0 ;
19180 int val6 ;
19181 int ecode6 = 0 ;
19182 bool val7 ;
19183 int ecode7 = 0 ;
19184 bool val8 ;
19185 int ecode8 = 0 ;
19186 bool val9 ;
19187 int ecode9 = 0 ;
19188 bool val10 ;
19189 int ecode10 = 0 ;
19190 PyObject * obj0 = 0 ;
19191 PyObject * obj1 = 0 ;
19192 PyObject * obj2 = 0 ;
19193 PyObject * obj3 = 0 ;
19194 PyObject * obj4 = 0 ;
19195 PyObject * obj5 = 0 ;
19196 PyObject * obj6 = 0 ;
19197 PyObject * obj7 = 0 ;
19198 PyObject * obj8 = 0 ;
19199 PyObject * obj9 = 0 ;
19200 char * kwnames[] = {
19201 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19202 };
19203
19204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19205 ecode1 = SWIG_AsVal_int(obj0, &val1);
19206 if (!SWIG_IsOK(ecode1)) {
19207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19208 }
19209 arg1 = static_cast< int >(val1);
19210 ecode2 = SWIG_AsVal_int(obj1, &val2);
19211 if (!SWIG_IsOK(ecode2)) {
19212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19213 }
19214 arg2 = static_cast< wxEventType >(val2);
19215 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19216 if (!SWIG_IsOK(res3)) {
19217 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19218 }
19219 arg3 = reinterpret_cast< wxGrid * >(argp3);
19220 if (obj3) {
19221 ecode4 = SWIG_AsVal_int(obj3, &val4);
19222 if (!SWIG_IsOK(ecode4)) {
19223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19224 }
19225 arg4 = static_cast< int >(val4);
19226 }
19227 if (obj4) {
19228 ecode5 = SWIG_AsVal_int(obj4, &val5);
19229 if (!SWIG_IsOK(ecode5)) {
19230 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19231 }
19232 arg5 = static_cast< int >(val5);
19233 }
19234 if (obj5) {
19235 ecode6 = SWIG_AsVal_int(obj5, &val6);
19236 if (!SWIG_IsOK(ecode6)) {
19237 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19238 }
19239 arg6 = static_cast< int >(val6);
19240 }
19241 if (obj6) {
19242 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19243 if (!SWIG_IsOK(ecode7)) {
19244 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19245 }
19246 arg7 = static_cast< bool >(val7);
19247 }
19248 if (obj7) {
19249 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19250 if (!SWIG_IsOK(ecode8)) {
19251 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19252 }
19253 arg8 = static_cast< bool >(val8);
19254 }
19255 if (obj8) {
19256 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19257 if (!SWIG_IsOK(ecode9)) {
19258 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19259 }
19260 arg9 = static_cast< bool >(val9);
19261 }
19262 if (obj9) {
19263 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19264 if (!SWIG_IsOK(ecode10)) {
19265 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19266 }
19267 arg10 = static_cast< bool >(val10);
19268 }
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19283 PyObject *resultobj = 0;
19284 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19285 int result;
19286 void *argp1 = 0 ;
19287 int res1 = 0 ;
19288 PyObject *swig_obj[1] ;
19289
19290 if (!args) SWIG_fail;
19291 swig_obj[0] = args;
19292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19293 if (!SWIG_IsOK(res1)) {
19294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19295 }
19296 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 result = (int)(arg1)->GetRowOrCol();
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 resultobj = SWIG_From_int(static_cast< int >(result));
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19311 PyObject *resultobj = 0;
19312 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19313 wxPoint result;
19314 void *argp1 = 0 ;
19315 int res1 = 0 ;
19316 PyObject *swig_obj[1] ;
19317
19318 if (!args) SWIG_fail;
19319 swig_obj[0] = args;
19320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19321 if (!SWIG_IsOK(res1)) {
19322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19323 }
19324 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = (arg1)->GetPosition();
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19332 return resultobj;
19333 fail:
19334 return NULL;
19335 }
19336
19337
19338 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19339 PyObject *resultobj = 0;
19340 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19341 bool result;
19342 void *argp1 = 0 ;
19343 int res1 = 0 ;
19344 PyObject *swig_obj[1] ;
19345
19346 if (!args) SWIG_fail;
19347 swig_obj[0] = args;
19348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19349 if (!SWIG_IsOK(res1)) {
19350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19351 }
19352 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 result = (bool)(arg1)->ControlDown();
19356 wxPyEndAllowThreads(__tstate);
19357 if (PyErr_Occurred()) SWIG_fail;
19358 }
19359 {
19360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19361 }
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19369 PyObject *resultobj = 0;
19370 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19371 bool result;
19372 void *argp1 = 0 ;
19373 int res1 = 0 ;
19374 PyObject *swig_obj[1] ;
19375
19376 if (!args) SWIG_fail;
19377 swig_obj[0] = args;
19378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19379 if (!SWIG_IsOK(res1)) {
19380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19381 }
19382 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19383 {
19384 PyThreadState* __tstate = wxPyBeginAllowThreads();
19385 result = (bool)(arg1)->MetaDown();
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 {
19390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19391 }
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19401 bool result;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject *swig_obj[1] ;
19405
19406 if (!args) SWIG_fail;
19407 swig_obj[0] = args;
19408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19411 }
19412 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 result = (bool)(arg1)->ShiftDown();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 {
19420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19421 }
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19429 PyObject *resultobj = 0;
19430 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19431 bool result;
19432 void *argp1 = 0 ;
19433 int res1 = 0 ;
19434 PyObject *swig_obj[1] ;
19435
19436 if (!args) SWIG_fail;
19437 swig_obj[0] = args;
19438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19439 if (!SWIG_IsOK(res1)) {
19440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19441 }
19442 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = (bool)(arg1)->AltDown();
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 {
19450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19451 }
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19459 PyObject *resultobj = 0;
19460 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19461 bool result;
19462 void *argp1 = 0 ;
19463 int res1 = 0 ;
19464 PyObject *swig_obj[1] ;
19465
19466 if (!args) SWIG_fail;
19467 swig_obj[0] = args;
19468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19469 if (!SWIG_IsOK(res1)) {
19470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19471 }
19472 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 result = (bool)(arg1)->CmdDown();
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 {
19480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19481 }
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19489 PyObject *obj;
19490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19491 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19492 return SWIG_Py_Void();
19493 }
19494
19495 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19496 return SWIG_Python_InitShadowInstance(args);
19497 }
19498
19499 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19500 PyObject *resultobj = 0;
19501 int arg1 ;
19502 wxEventType arg2 ;
19503 wxGrid *arg3 = (wxGrid *) 0 ;
19504 wxGridCellCoords *arg4 = 0 ;
19505 wxGridCellCoords *arg5 = 0 ;
19506 bool arg6 = (bool) true ;
19507 bool arg7 = (bool) false ;
19508 bool arg8 = (bool) false ;
19509 bool arg9 = (bool) false ;
19510 bool arg10 = (bool) false ;
19511 wxGridRangeSelectEvent *result = 0 ;
19512 int val1 ;
19513 int ecode1 = 0 ;
19514 int val2 ;
19515 int ecode2 = 0 ;
19516 void *argp3 = 0 ;
19517 int res3 = 0 ;
19518 wxGridCellCoords temp4 ;
19519 wxGridCellCoords temp5 ;
19520 bool val6 ;
19521 int ecode6 = 0 ;
19522 bool val7 ;
19523 int ecode7 = 0 ;
19524 bool val8 ;
19525 int ecode8 = 0 ;
19526 bool val9 ;
19527 int ecode9 = 0 ;
19528 bool val10 ;
19529 int ecode10 = 0 ;
19530 PyObject * obj0 = 0 ;
19531 PyObject * obj1 = 0 ;
19532 PyObject * obj2 = 0 ;
19533 PyObject * obj3 = 0 ;
19534 PyObject * obj4 = 0 ;
19535 PyObject * obj5 = 0 ;
19536 PyObject * obj6 = 0 ;
19537 PyObject * obj7 = 0 ;
19538 PyObject * obj8 = 0 ;
19539 PyObject * obj9 = 0 ;
19540 char * kwnames[] = {
19541 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19542 };
19543
19544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19545 ecode1 = SWIG_AsVal_int(obj0, &val1);
19546 if (!SWIG_IsOK(ecode1)) {
19547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19548 }
19549 arg1 = static_cast< int >(val1);
19550 ecode2 = SWIG_AsVal_int(obj1, &val2);
19551 if (!SWIG_IsOK(ecode2)) {
19552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19553 }
19554 arg2 = static_cast< wxEventType >(val2);
19555 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19556 if (!SWIG_IsOK(res3)) {
19557 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19558 }
19559 arg3 = reinterpret_cast< wxGrid * >(argp3);
19560 {
19561 arg4 = &temp4;
19562 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19563 }
19564 {
19565 arg5 = &temp5;
19566 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19567 }
19568 if (obj5) {
19569 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19570 if (!SWIG_IsOK(ecode6)) {
19571 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19572 }
19573 arg6 = static_cast< bool >(val6);
19574 }
19575 if (obj6) {
19576 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19577 if (!SWIG_IsOK(ecode7)) {
19578 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19579 }
19580 arg7 = static_cast< bool >(val7);
19581 }
19582 if (obj7) {
19583 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19584 if (!SWIG_IsOK(ecode8)) {
19585 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19586 }
19587 arg8 = static_cast< bool >(val8);
19588 }
19589 if (obj8) {
19590 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19591 if (!SWIG_IsOK(ecode9)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19593 }
19594 arg9 = static_cast< bool >(val9);
19595 }
19596 if (obj9) {
19597 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19598 if (!SWIG_IsOK(ecode10)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19600 }
19601 arg10 = static_cast< bool >(val10);
19602 }
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *resultobj = 0;
19618 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19619 wxGridCellCoords result;
19620 void *argp1 = 0 ;
19621 int res1 = 0 ;
19622 PyObject *swig_obj[1] ;
19623
19624 if (!args) SWIG_fail;
19625 swig_obj[0] = args;
19626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19627 if (!SWIG_IsOK(res1)) {
19628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19629 }
19630 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19631 {
19632 PyThreadState* __tstate = wxPyBeginAllowThreads();
19633 result = (arg1)->GetTopLeftCoords();
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *resultobj = 0;
19646 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19647 wxGridCellCoords result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 PyObject *swig_obj[1] ;
19651
19652 if (!args) SWIG_fail;
19653 swig_obj[0] = args;
19654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19655 if (!SWIG_IsOK(res1)) {
19656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19657 }
19658 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = (arg1)->GetBottomRightCoords();
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19673 PyObject *resultobj = 0;
19674 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19675 int result;
19676 void *argp1 = 0 ;
19677 int res1 = 0 ;
19678 PyObject *swig_obj[1] ;
19679
19680 if (!args) SWIG_fail;
19681 swig_obj[0] = args;
19682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19683 if (!SWIG_IsOK(res1)) {
19684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19685 }
19686 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = (int)(arg1)->GetTopRow();
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_From_int(static_cast< int >(result));
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19703 int result;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19713 }
19714 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (int)(arg1)->GetBottomRow();
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_From_int(static_cast< int >(result));
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19741 }
19742 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)(arg1)->GetLeftCol();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19769 }
19770 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)(arg1)->GetRightCol();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *resultobj = 0;
19786 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19787 bool result;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 PyObject *swig_obj[1] ;
19791
19792 if (!args) SWIG_fail;
19793 swig_obj[0] = args;
19794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19795 if (!SWIG_IsOK(res1)) {
19796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19797 }
19798 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (bool)(arg1)->Selecting();
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 PyObject *resultobj = 0;
19816 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19817 bool result;
19818 void *argp1 = 0 ;
19819 int res1 = 0 ;
19820 PyObject *swig_obj[1] ;
19821
19822 if (!args) SWIG_fail;
19823 swig_obj[0] = args;
19824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19825 if (!SWIG_IsOK(res1)) {
19826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19827 }
19828 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19829 {
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 result = (bool)(arg1)->ControlDown();
19832 wxPyEndAllowThreads(__tstate);
19833 if (PyErr_Occurred()) SWIG_fail;
19834 }
19835 {
19836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19837 }
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19845 PyObject *resultobj = 0;
19846 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19847 bool result;
19848 void *argp1 = 0 ;
19849 int res1 = 0 ;
19850 PyObject *swig_obj[1] ;
19851
19852 if (!args) SWIG_fail;
19853 swig_obj[0] = args;
19854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19855 if (!SWIG_IsOK(res1)) {
19856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19857 }
19858 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19859 {
19860 PyThreadState* __tstate = wxPyBeginAllowThreads();
19861 result = (bool)(arg1)->MetaDown();
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 {
19866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19867 }
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19875 PyObject *resultobj = 0;
19876 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19877 bool result;
19878 void *argp1 = 0 ;
19879 int res1 = 0 ;
19880 PyObject *swig_obj[1] ;
19881
19882 if (!args) SWIG_fail;
19883 swig_obj[0] = args;
19884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19885 if (!SWIG_IsOK(res1)) {
19886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19887 }
19888 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19889 {
19890 PyThreadState* __tstate = wxPyBeginAllowThreads();
19891 result = (bool)(arg1)->ShiftDown();
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 {
19896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19897 }
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19905 PyObject *resultobj = 0;
19906 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19907 bool result;
19908 void *argp1 = 0 ;
19909 int res1 = 0 ;
19910 PyObject *swig_obj[1] ;
19911
19912 if (!args) SWIG_fail;
19913 swig_obj[0] = args;
19914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19917 }
19918 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (bool)(arg1)->AltDown();
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19927 }
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19935 PyObject *resultobj = 0;
19936 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19937 bool result;
19938 void *argp1 = 0 ;
19939 int res1 = 0 ;
19940 PyObject *swig_obj[1] ;
19941
19942 if (!args) SWIG_fail;
19943 swig_obj[0] = args;
19944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19945 if (!SWIG_IsOK(res1)) {
19946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19947 }
19948 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19949 {
19950 PyThreadState* __tstate = wxPyBeginAllowThreads();
19951 result = (bool)(arg1)->CmdDown();
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 {
19956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19957 }
19958 return resultobj;
19959 fail:
19960 return NULL;
19961 }
19962
19963
19964 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19965 PyObject *obj;
19966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19967 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19968 return SWIG_Py_Void();
19969 }
19970
19971 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19972 return SWIG_Python_InitShadowInstance(args);
19973 }
19974
19975 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj = 0;
19977 int arg1 ;
19978 wxEventType arg2 ;
19979 wxObject *arg3 = (wxObject *) 0 ;
19980 int arg4 ;
19981 int arg5 ;
19982 wxControl *arg6 = (wxControl *) 0 ;
19983 wxGridEditorCreatedEvent *result = 0 ;
19984 int val1 ;
19985 int ecode1 = 0 ;
19986 int val2 ;
19987 int ecode2 = 0 ;
19988 void *argp3 = 0 ;
19989 int res3 = 0 ;
19990 int val4 ;
19991 int ecode4 = 0 ;
19992 int val5 ;
19993 int ecode5 = 0 ;
19994 void *argp6 = 0 ;
19995 int res6 = 0 ;
19996 PyObject * obj0 = 0 ;
19997 PyObject * obj1 = 0 ;
19998 PyObject * obj2 = 0 ;
19999 PyObject * obj3 = 0 ;
20000 PyObject * obj4 = 0 ;
20001 PyObject * obj5 = 0 ;
20002 char * kwnames[] = {
20003 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20004 };
20005
20006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20007 ecode1 = SWIG_AsVal_int(obj0, &val1);
20008 if (!SWIG_IsOK(ecode1)) {
20009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20010 }
20011 arg1 = static_cast< int >(val1);
20012 ecode2 = SWIG_AsVal_int(obj1, &val2);
20013 if (!SWIG_IsOK(ecode2)) {
20014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20015 }
20016 arg2 = static_cast< wxEventType >(val2);
20017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20018 if (!SWIG_IsOK(res3)) {
20019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20020 }
20021 arg3 = reinterpret_cast< wxObject * >(argp3);
20022 ecode4 = SWIG_AsVal_int(obj3, &val4);
20023 if (!SWIG_IsOK(ecode4)) {
20024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20025 }
20026 arg4 = static_cast< int >(val4);
20027 ecode5 = SWIG_AsVal_int(obj4, &val5);
20028 if (!SWIG_IsOK(ecode5)) {
20029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20030 }
20031 arg5 = static_cast< int >(val5);
20032 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20033 if (!SWIG_IsOK(res6)) {
20034 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20035 }
20036 arg6 = reinterpret_cast< wxControl * >(argp6);
20037 {
20038 PyThreadState* __tstate = wxPyBeginAllowThreads();
20039 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20040 wxPyEndAllowThreads(__tstate);
20041 if (PyErr_Occurred()) SWIG_fail;
20042 }
20043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20044 return resultobj;
20045 fail:
20046 return NULL;
20047 }
20048
20049
20050 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20051 PyObject *resultobj = 0;
20052 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20053 int result;
20054 void *argp1 = 0 ;
20055 int res1 = 0 ;
20056 PyObject *swig_obj[1] ;
20057
20058 if (!args) SWIG_fail;
20059 swig_obj[0] = args;
20060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20061 if (!SWIG_IsOK(res1)) {
20062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20063 }
20064 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20065 {
20066 PyThreadState* __tstate = wxPyBeginAllowThreads();
20067 result = (int)(arg1)->GetRow();
20068 wxPyEndAllowThreads(__tstate);
20069 if (PyErr_Occurred()) SWIG_fail;
20070 }
20071 resultobj = SWIG_From_int(static_cast< int >(result));
20072 return resultobj;
20073 fail:
20074 return NULL;
20075 }
20076
20077
20078 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20079 PyObject *resultobj = 0;
20080 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20081 int result;
20082 void *argp1 = 0 ;
20083 int res1 = 0 ;
20084 PyObject *swig_obj[1] ;
20085
20086 if (!args) SWIG_fail;
20087 swig_obj[0] = args;
20088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20089 if (!SWIG_IsOK(res1)) {
20090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20091 }
20092 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20093 {
20094 PyThreadState* __tstate = wxPyBeginAllowThreads();
20095 result = (int)(arg1)->GetCol();
20096 wxPyEndAllowThreads(__tstate);
20097 if (PyErr_Occurred()) SWIG_fail;
20098 }
20099 resultobj = SWIG_From_int(static_cast< int >(result));
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20107 PyObject *resultobj = 0;
20108 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20109 wxControl *result = 0 ;
20110 void *argp1 = 0 ;
20111 int res1 = 0 ;
20112 PyObject *swig_obj[1] ;
20113
20114 if (!args) SWIG_fail;
20115 swig_obj[0] = args;
20116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20117 if (!SWIG_IsOK(res1)) {
20118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20119 }
20120 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 result = (wxControl *)(arg1)->GetControl();
20124 wxPyEndAllowThreads(__tstate);
20125 if (PyErr_Occurred()) SWIG_fail;
20126 }
20127 {
20128 resultobj = wxPyMake_wxObject(result, 0);
20129 }
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20137 PyObject *resultobj = 0;
20138 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20139 int arg2 ;
20140 void *argp1 = 0 ;
20141 int res1 = 0 ;
20142 int val2 ;
20143 int ecode2 = 0 ;
20144 PyObject * obj0 = 0 ;
20145 PyObject * obj1 = 0 ;
20146 char * kwnames[] = {
20147 (char *) "self",(char *) "row", NULL
20148 };
20149
20150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20152 if (!SWIG_IsOK(res1)) {
20153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20154 }
20155 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20156 ecode2 = SWIG_AsVal_int(obj1, &val2);
20157 if (!SWIG_IsOK(ecode2)) {
20158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20159 }
20160 arg2 = static_cast< int >(val2);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 (arg1)->SetRow(arg2);
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_Py_Void();
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj = 0;
20176 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20177 int arg2 ;
20178 void *argp1 = 0 ;
20179 int res1 = 0 ;
20180 int val2 ;
20181 int ecode2 = 0 ;
20182 PyObject * obj0 = 0 ;
20183 PyObject * obj1 = 0 ;
20184 char * kwnames[] = {
20185 (char *) "self",(char *) "col", NULL
20186 };
20187
20188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20192 }
20193 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20194 ecode2 = SWIG_AsVal_int(obj1, &val2);
20195 if (!SWIG_IsOK(ecode2)) {
20196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20197 }
20198 arg2 = static_cast< int >(val2);
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 (arg1)->SetCol(arg2);
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 resultobj = SWIG_Py_Void();
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj = 0;
20214 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20215 wxControl *arg2 = (wxControl *) 0 ;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 void *argp2 = 0 ;
20219 int res2 = 0 ;
20220 PyObject * obj0 = 0 ;
20221 PyObject * obj1 = 0 ;
20222 char * kwnames[] = {
20223 (char *) "self",(char *) "ctrl", NULL
20224 };
20225
20226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20228 if (!SWIG_IsOK(res1)) {
20229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20230 }
20231 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20233 if (!SWIG_IsOK(res2)) {
20234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20235 }
20236 arg2 = reinterpret_cast< wxControl * >(argp2);
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 (arg1)->SetControl(arg2);
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 resultobj = SWIG_Py_Void();
20244 return resultobj;
20245 fail:
20246 return NULL;
20247 }
20248
20249
20250 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20251 PyObject *obj;
20252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20253 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20254 return SWIG_Py_Void();
20255 }
20256
20257 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 return SWIG_Python_InitShadowInstance(args);
20259 }
20260
20261 static PyMethodDef SwigMethods[] = {
20262 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20263 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20264 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20265 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20266 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20267 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20268 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20269 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20270 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20271 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20272 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20273 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20274 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20275 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20276 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20277 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20278 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20279 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20280 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20281 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20282 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20283 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20284 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20285 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20286 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20287 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20288 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20289 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20290 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20291 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20292 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20293 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20294 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20295 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20296 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20297 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20298 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20299 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20300 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20301 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20302 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20303 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20304 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20305 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20306 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20307 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20308 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20309 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20310 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20313 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20314 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20315 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20316 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20317 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20318 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20319 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20320 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20321 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20322 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20323 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20324 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20325 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20326 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20327 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20328 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20329 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20330 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20331 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20332 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20333 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20334 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20335 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20336 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20337 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20338 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20339 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20340 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20341 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20342 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20343 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20344 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20345 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20346 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20347 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20348 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20349 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20350 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20351 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20353 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20354 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20355 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20358 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20363 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20364 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20365 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20366 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20367 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20368 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20369 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20370 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20371 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20372 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20373 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20374 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20375 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20376 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20377 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20378 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20381 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20382 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20384 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20385 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20386 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20394 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20395 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20396 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20402 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20403 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20404 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20405 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20406 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20407 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20408 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20409 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20410 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20411 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20424 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20435 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20440 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20441 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20442 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20443 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20444 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20445 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20447 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20448 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20450 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20452 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20453 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20454 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20456 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20458 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20459 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20460 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20462 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20463 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20465 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20470 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20471 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20472 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20473 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20474 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20478 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20479 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20480 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20482 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20484 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20494 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20495 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20496 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20497 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20498 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20501 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20502 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20503 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20504 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20505 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20506 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20507 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20508 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20515 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20516 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20524 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20525 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20530 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20531 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20532 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20533 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20534 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20535 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20536 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20537 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20538 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20539 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20542 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20543 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20544 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20545 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20561 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20562 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20564 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20565 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20567 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20568 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20570 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20571 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20573 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20574 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20584 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20585 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20587 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20589 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20591 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20593 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20595 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20597 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20611 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20618 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20619 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20633 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20637 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20646 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20647 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20648 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20650 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20651 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20652 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20653 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20654 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20659 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20660 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20669 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20670 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20671 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20672 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20675 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20676 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20680 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20681 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20683 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20684 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20685 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20686 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20687 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20688 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20689 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20690 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20691 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20692 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20693 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20695 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20696 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20697 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20698 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20699 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20700 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20701 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20702 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20703 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20705 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20706 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20707 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20708 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20709 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20710 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20711 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20712 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20713 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20714 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20715 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20716 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20717 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20718 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20720 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20721 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20722 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20726 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20727 { NULL, NULL, 0, NULL }
20728 };
20729
20730
20731 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20732
20733 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20734 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20735 }
20736 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20737 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20738 }
20739 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20740 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20741 }
20742 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20743 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20744 }
20745 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20746 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20747 }
20748 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20749 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20750 }
20751 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20752 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20753 }
20754 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20755 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20756 }
20757 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20758 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20759 }
20760 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20761 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20762 }
20763 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20764 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20765 }
20766 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20767 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20768 }
20769 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20770 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20771 }
20772 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20773 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20774 }
20775 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20776 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20777 }
20778 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20779 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20780 }
20781 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20782 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20783 }
20784 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20785 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20786 }
20787 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20788 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20789 }
20790 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20791 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20792 }
20793 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20794 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20795 }
20796 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20797 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20798 }
20799 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20800 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20801 }
20802 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20803 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20804 }
20805 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20806 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20807 }
20808 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20809 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20810 }
20811 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20812 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20813 }
20814 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20815 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20816 }
20817 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20818 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20819 }
20820 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20821 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20822 }
20823 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20824 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20825 }
20826 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20827 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20828 }
20829 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20830 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20831 }
20832 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20833 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20834 }
20835 static void *_p_wxGridTo_p_wxPanel(void *x) {
20836 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20837 }
20838 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20839 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20840 }
20841 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20842 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20843 }
20844 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20845 return (void *)((wxPanel *) ((wxPyPanel *) x));
20846 }
20847 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20848 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20849 }
20850 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20851 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20852 }
20853 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20854 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20855 }
20856 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20857 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20858 }
20859 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20860 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20861 }
20862 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20863 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20864 }
20865 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20866 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20867 }
20868 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20869 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20870 }
20871 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20872 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20873 }
20874 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20875 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20876 }
20877 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20878 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20879 }
20880 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20881 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20882 }
20883 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20884 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20885 }
20886 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20887 return (void *)((wxWindow *) ((wxMenuBar *) x));
20888 }
20889 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20890 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20891 }
20892 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20893 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20894 }
20895 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20896 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20897 }
20898 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
20899 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
20900 }
20901 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20902 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20903 }
20904 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20905 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20906 }
20907 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20908 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20909 }
20910 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20911 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20912 }
20913 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20914 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20915 }
20916 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20917 return (void *)((wxWindow *) ((wxPanel *) x));
20918 }
20919 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20920 return (void *)((wxWindow *) ((wxStatusBar *) x));
20921 }
20922 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20923 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20924 }
20925 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20926 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
20927 }
20928 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20929 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20930 }
20931 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20932 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20933 }
20934 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20935 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20936 }
20937 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20938 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20939 }
20940 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20941 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20942 }
20943 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20944 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20945 }
20946 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20947 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20948 }
20949 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20950 return (void *)((wxWindow *) ((wxSashWindow *) x));
20951 }
20952 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20953 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20954 }
20955 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20956 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20957 }
20958 static void *_p_wxControlTo_p_wxWindow(void *x) {
20959 return (void *)((wxWindow *) ((wxControl *) x));
20960 }
20961 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20962 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20963 }
20964 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20965 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20966 }
20967 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20968 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20969 }
20970 static void *_p_wxGridTo_p_wxWindow(void *x) {
20971 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20972 }
20973 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20974 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20975 }
20976 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20977 return (void *)((wxWindow *) ((wxPyWindow *) x));
20978 }
20979 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20980 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20981 }
20982 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20983 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20984 }
20985 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20986 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20987 }
20988 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20989 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20990 }
20991 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20992 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20993 }
20994 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20995 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20996 }
20997 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20998 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20999 }
21000 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21001 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21002 }
21003 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21004 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21005 }
21006 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21007 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21008 }
21009 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21010 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21011 }
21012 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21013 return (void *)((wxControl *) ((wxControlWithItems *) x));
21014 }
21015 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21016 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21017 }
21018 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21019 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21020 }
21021 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21022 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21023 }
21024 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21025 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21026 }
21027 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21028 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21029 }
21030 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21031 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21032 }
21033 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21034 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21035 }
21036 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21037 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21038 }
21039 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21040 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21041 }
21042 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21043 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21044 }
21045 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21046 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21047 }
21048 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21049 return (void *)((wxEvent *) ((wxPyEvent *) x));
21050 }
21051 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21052 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21053 }
21054 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21055 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21056 }
21057 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21058 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21059 }
21060 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21061 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21062 }
21063 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21064 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21065 }
21066 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21067 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21068 }
21069 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21070 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21071 }
21072 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21073 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21074 }
21075 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21076 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21077 }
21078 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21079 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21080 }
21081 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21082 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21083 }
21084 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21085 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21086 }
21087 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21088 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21089 }
21090 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21091 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21092 }
21093 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21094 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21095 }
21096 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21098 }
21099 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21100 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21101 }
21102 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21103 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21104 }
21105 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21106 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21107 }
21108 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21109 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21110 }
21111 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21112 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21113 }
21114 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21115 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21116 }
21117 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21118 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21119 }
21120 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21121 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21122 }
21123 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21124 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21125 }
21126 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21128 }
21129 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21130 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21131 }
21132 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21133 return (void *)((wxEvent *) ((wxShowEvent *) x));
21134 }
21135 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21136 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21137 }
21138 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21140 }
21141 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21142 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21143 }
21144 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21145 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21146 }
21147 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21148 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21149 }
21150 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21151 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21152 }
21153 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21154 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21155 }
21156 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21157 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21158 }
21159 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21160 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21161 }
21162 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21163 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21164 }
21165 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21166 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21167 }
21168 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21169 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21170 }
21171 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21172 return (void *)((wxObject *) ((wxSizerItem *) x));
21173 }
21174 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21176 }
21177 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21178 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21179 }
21180 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21181 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21182 }
21183 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21184 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21185 }
21186 static void *_p_wxSizerTo_p_wxObject(void *x) {
21187 return (void *)((wxObject *) ((wxSizer *) x));
21188 }
21189 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21190 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21191 }
21192 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21193 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21194 }
21195 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21196 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21197 }
21198 static void *_p_wxEventTo_p_wxObject(void *x) {
21199 return (void *)((wxObject *) ((wxEvent *) x));
21200 }
21201 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21202 return (void *)((wxObject *) ((wxFontData *) x));
21203 }
21204 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21205 return (void *)((wxObject *) ((wxPrintData *) x));
21206 }
21207 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21208 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21209 }
21210 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21211 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21212 }
21213 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21214 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21215 }
21216 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21217 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21218 }
21219 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21220 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21221 }
21222 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21223 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21224 }
21225 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21226 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21227 }
21228 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21229 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21230 }
21231 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21232 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21233 }
21234 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21235 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21236 }
21237 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21238 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21239 }
21240 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21241 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21242 }
21243 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21244 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21245 }
21246 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21247 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21248 }
21249 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21250 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21251 }
21252 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21253 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21254 }
21255 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21256 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21257 }
21258 static void *_p_wxControlTo_p_wxObject(void *x) {
21259 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21260 }
21261 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21262 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21263 }
21264 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21265 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21266 }
21267 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21268 return (void *)((wxObject *) ((wxFSFile *) x));
21269 }
21270 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21271 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21272 }
21273 static void *_p_wxGridTo_p_wxObject(void *x) {
21274 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21275 }
21276 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21277 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21278 }
21279 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21280 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21281 }
21282 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21283 return (void *)((wxObject *) ((wxColourData *) x));
21284 }
21285 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21286 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21287 }
21288 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21290 }
21291 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21292 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21293 }
21294 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21295 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21296 }
21297 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21298 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21299 }
21300 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21301 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21302 }
21303 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21304 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21305 }
21306 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21307 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21308 }
21309 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21310 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21311 }
21312 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21313 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21314 }
21315 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21316 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21317 }
21318 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21319 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21320 }
21321 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21322 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21323 }
21324 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21325 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21326 }
21327 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21328 return (void *)((wxObject *) ((wxPrinter *) x));
21329 }
21330 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21331 return (void *)((wxObject *) ((wxMenuItem *) x));
21332 }
21333 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21335 }
21336 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21337 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21338 }
21339 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21340 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21341 }
21342 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21343 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21344 }
21345 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21346 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21347 }
21348 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21349 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21350 }
21351 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21352 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21353 }
21354 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21355 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21356 }
21357 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21358 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21359 }
21360 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21361 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21362 }
21363 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21364 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21365 }
21366 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21367 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21368 }
21369 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21370 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21371 }
21372 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21373 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21374 }
21375 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21376 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21377 }
21378 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21379 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21380 }
21381 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21382 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21383 }
21384 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21385 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21386 }
21387 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21388 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21389 }
21390 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21391 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21392 }
21393 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21394 return (void *)((wxObject *) ((wxImageHandler *) x));
21395 }
21396 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21397 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21398 }
21399 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21400 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21401 }
21402 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21403 return (void *)((wxObject *) ((wxEvtHandler *) x));
21404 }
21405 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21406 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21407 }
21408 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21409 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21410 }
21411 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21412 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21413 }
21414 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21415 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21416 }
21417 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21418 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21419 }
21420 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21421 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21422 }
21423 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21424 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21425 }
21426 static void *_p_wxImageTo_p_wxObject(void *x) {
21427 return (void *)((wxObject *) ((wxImage *) x));
21428 }
21429 static void *_p_wxFrameTo_p_wxObject(void *x) {
21430 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21431 }
21432 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21433 return (void *)((wxObject *) ((wxPyPrintout *) x));
21434 }
21435 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21436 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21437 }
21438 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21439 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21440 }
21441 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21442 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21443 }
21444 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21445 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21446 }
21447 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21449 }
21450 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21451 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21452 }
21453 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21454 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21455 }
21456 static void *_p_wxWindowTo_p_wxObject(void *x) {
21457 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21458 }
21459 static void *_p_wxMenuTo_p_wxObject(void *x) {
21460 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21461 }
21462 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21463 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21464 }
21465 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21466 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21467 }
21468 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21469 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21470 }
21471 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21472 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21473 }
21474 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21475 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21476 }
21477 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21478 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21479 }
21480 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21481 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21482 }
21483 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21484 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21485 }
21486 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21487 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21488 }
21489 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21490 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21491 }
21492 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21493 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21494 }
21495 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21496 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21497 }
21498 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21499 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21500 }
21501 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21503 }
21504 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21505 return (void *)((wxObject *) ((wxPrintPreview *) x));
21506 }
21507 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21508 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21509 }
21510 static void *_p_wxPanelTo_p_wxObject(void *x) {
21511 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21512 }
21513 static void *_p_wxDialogTo_p_wxObject(void *x) {
21514 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21515 }
21516 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21517 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21518 }
21519 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21520 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21521 }
21522 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21523 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21524 }
21525 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21527 }
21528 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) ((wxPrintDialog *) x));
21530 }
21531 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) ((wxFileSystem *) x));
21533 }
21534 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21536 }
21537 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21539 }
21540 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21542 }
21543 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21545 }
21546 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21548 }
21549 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21551 }
21552 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) ((wxGridTableBase *) x));
21554 }
21555 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21557 }
21558 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21560 }
21561 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21563 }
21564 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21566 }
21567 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21569 }
21570 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21572 }
21573 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21575 }
21576 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21578 }
21579 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21581 }
21582 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21584 }
21585 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21587 }
21588 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21590 }
21591 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21593 }
21594 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21595 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21596 }
21597 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21598 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21599 }
21600 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21601 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21602 }
21603 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21604 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21605 }
21606 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21607 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21608 }
21609 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21610 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21611 }
21612 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21613 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21614 }
21615 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21616 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21617 }
21618 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21619 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21620 }
21621 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21622 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21623 }
21624 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21625 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21626 }
21627 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21628 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21629 }
21630 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
21631 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21632 }
21633 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21634 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21635 }
21636 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21637 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21638 }
21639 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21640 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21641 }
21642 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21643 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21644 }
21645 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21646 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21647 }
21648 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21649 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21650 }
21651 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21652 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21653 }
21654 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21655 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21656 }
21657 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21658 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21659 }
21660 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21661 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21662 }
21663 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21664 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21665 }
21666 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21667 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21668 }
21669 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21670 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21671 }
21672 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21673 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21674 }
21675 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21676 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21677 }
21678 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21679 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21680 }
21681 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21682 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21683 }
21684 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21685 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21686 }
21687 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21688 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21689 }
21690 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21691 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21692 }
21693 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21694 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21695 }
21696 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21697 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21698 }
21699 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21700 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21701 }
21702 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21703 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21704 }
21705 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21706 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21707 }
21708 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21709 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21710 }
21711 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21712 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21713 }
21714 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21715 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21716 }
21717 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21718 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21719 }
21720 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21721 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21722 }
21723 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21724 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21725 }
21726 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21727 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21728 }
21729 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21730 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21731 }
21732 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21733 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21734 }
21735 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21736 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21737 }
21738 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21739 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21740 }
21741 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21742 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21743 }
21744 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21745 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21746 }
21747 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21748 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21749 }
21750 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21751 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21752 }
21753 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21754 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21755 }
21756 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21757 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21758 }
21759 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21760 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21761 }
21762 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21763 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21764 }
21765 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21766 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21767 }
21768 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21769 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21770 }
21771 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21772 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21773 }
21774 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21775 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21776 }
21777 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21778 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21779 }
21780 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21781 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21782 }
21783 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21784 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21785 }
21786 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21787 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21788 }
21789 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21790 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21791 }
21792 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21793 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21794 }
21795 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21796 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21797 }
21798 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21799 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21800 }
21801 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21802 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21803 }
21804 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21805 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21806 }
21807 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21808 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21809 }
21810 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21811 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21812 }
21813 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21814 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21815 }
21816 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21817 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21818 }
21819 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21820 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21821 }
21822 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21823 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21824 }
21825 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21826 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21827 }
21828 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21829 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21830 }
21831 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21832 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21833 }
21834 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21835 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21836 }
21837 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21838 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21839 }
21840 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21841 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21842 }
21843 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21844 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};
21845 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21846 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21847 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21848 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21849 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21850 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21851 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21852 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21853 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21854 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21855 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21856 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21857 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21858 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21859 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21860 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21861 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21862 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21863 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21864 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21865 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21866 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21867 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21868 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21869 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21870 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21871 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21872 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21873 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21874 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21875 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21876 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21877 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21878 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21879 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21880 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21881 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21882 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21883 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21884 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21885 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21886 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21887 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21888 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21889 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21890 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21891 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21892 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21893 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21894 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21895 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21896 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21897 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21898 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21899 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21900 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21901 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21902 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21903 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21904 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21905 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
21906 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21907 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21908 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21909 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21910 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21911 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21912 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21913 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21914 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21915 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21916 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21917 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21918 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21919 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21920 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21921 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21922 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21923 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21924 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21925 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21926 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21927 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21928 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21929 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21930 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21931 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21932 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21933 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21934 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21935 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21936 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21937 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21938 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21939 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21940 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21941 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21942 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21943 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21944 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21945 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21946 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21947 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21948 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21949 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21950 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21951 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21952 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21953 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21954 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21955 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21956 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21957 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21958 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21959 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21960 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21961 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21962 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21963 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21964 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21965 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21966 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21967 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21968 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21969 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21970 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21971 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21972 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21973 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21974 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21975 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21976 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21978 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21979 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21980 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21983 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21985 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21986 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21987 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21993 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21994 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21995 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21996 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21997 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21998 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21999 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22000 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22001 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22002 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22003 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22004 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22005 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22006 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22007 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22008 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22009 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22010 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22011 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22012 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22013 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22014 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22015 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22016 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22017 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22018 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22019 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22020 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22021 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22022 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22023 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22024 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22025 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22026 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22027 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22028 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22029 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22030 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22031
22032 static swig_type_info *swig_type_initial[] = {
22033 &_swigt__p_char,
22034 &_swigt__p_form_ops_t,
22035 &_swigt__p_int,
22036 &_swigt__p_long,
22037 &_swigt__p_unsigned_char,
22038 &_swigt__p_unsigned_int,
22039 &_swigt__p_unsigned_long,
22040 &_swigt__p_wxANIHandler,
22041 &_swigt__p_wxAcceleratorTable,
22042 &_swigt__p_wxActivateEvent,
22043 &_swigt__p_wxArrayString,
22044 &_swigt__p_wxBMPHandler,
22045 &_swigt__p_wxBoxSizer,
22046 &_swigt__p_wxCURHandler,
22047 &_swigt__p_wxCalculateLayoutEvent,
22048 &_swigt__p_wxChildFocusEvent,
22049 &_swigt__p_wxClipboardTextEvent,
22050 &_swigt__p_wxCloseEvent,
22051 &_swigt__p_wxColour,
22052 &_swigt__p_wxColourData,
22053 &_swigt__p_wxColourDialog,
22054 &_swigt__p_wxCommandEvent,
22055 &_swigt__p_wxContextMenuEvent,
22056 &_swigt__p_wxControl,
22057 &_swigt__p_wxControlWithItems,
22058 &_swigt__p_wxDC,
22059 &_swigt__p_wxDateEvent,
22060 &_swigt__p_wxDialog,
22061 &_swigt__p_wxDirDialog,
22062 &_swigt__p_wxDisplayChangedEvent,
22063 &_swigt__p_wxDropFilesEvent,
22064 &_swigt__p_wxDuplexMode,
22065 &_swigt__p_wxEraseEvent,
22066 &_swigt__p_wxEvent,
22067 &_swigt__p_wxEvtHandler,
22068 &_swigt__p_wxFSFile,
22069 &_swigt__p_wxFileDialog,
22070 &_swigt__p_wxFileSystem,
22071 &_swigt__p_wxFindDialogEvent,
22072 &_swigt__p_wxFindReplaceData,
22073 &_swigt__p_wxFindReplaceDialog,
22074 &_swigt__p_wxFlexGridSizer,
22075 &_swigt__p_wxFocusEvent,
22076 &_swigt__p_wxFont,
22077 &_swigt__p_wxFontData,
22078 &_swigt__p_wxFontDialog,
22079 &_swigt__p_wxFrame,
22080 &_swigt__p_wxGBSizerItem,
22081 &_swigt__p_wxGIFHandler,
22082 &_swigt__p_wxGrid,
22083 &_swigt__p_wxGridBagSizer,
22084 &_swigt__p_wxGridCellAttr,
22085 &_swigt__p_wxGridCellAttrProvider,
22086 &_swigt__p_wxGridCellAutoWrapStringEditor,
22087 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22088 &_swigt__p_wxGridCellBoolEditor,
22089 &_swigt__p_wxGridCellBoolRenderer,
22090 &_swigt__p_wxGridCellChoiceEditor,
22091 &_swigt__p_wxGridCellCoords,
22092 &_swigt__p_wxGridCellDateTimeRenderer,
22093 &_swigt__p_wxGridCellEditor,
22094 &_swigt__p_wxGridCellEnumEditor,
22095 &_swigt__p_wxGridCellEnumRenderer,
22096 &_swigt__p_wxGridCellFloatEditor,
22097 &_swigt__p_wxGridCellFloatRenderer,
22098 &_swigt__p_wxGridCellNumberEditor,
22099 &_swigt__p_wxGridCellNumberRenderer,
22100 &_swigt__p_wxGridCellRenderer,
22101 &_swigt__p_wxGridCellStringRenderer,
22102 &_swigt__p_wxGridCellTextEditor,
22103 &_swigt__p_wxGridCellWorker,
22104 &_swigt__p_wxGridEditorCreatedEvent,
22105 &_swigt__p_wxGridEvent,
22106 &_swigt__p_wxGridRangeSelectEvent,
22107 &_swigt__p_wxGridSizeEvent,
22108 &_swigt__p_wxGridSizer,
22109 &_swigt__p_wxGridStringTable,
22110 &_swigt__p_wxGridTableBase,
22111 &_swigt__p_wxGridTableMessage,
22112 &_swigt__p_wxICOHandler,
22113 &_swigt__p_wxIconizeEvent,
22114 &_swigt__p_wxIdleEvent,
22115 &_swigt__p_wxImage,
22116 &_swigt__p_wxImageHandler,
22117 &_swigt__p_wxIndividualLayoutConstraint,
22118 &_swigt__p_wxInitDialogEvent,
22119 &_swigt__p_wxJPEGHandler,
22120 &_swigt__p_wxKeyEvent,
22121 &_swigt__p_wxLayoutAlgorithm,
22122 &_swigt__p_wxLayoutConstraints,
22123 &_swigt__p_wxMDIChildFrame,
22124 &_swigt__p_wxMDIClientWindow,
22125 &_swigt__p_wxMDIParentFrame,
22126 &_swigt__p_wxMaximizeEvent,
22127 &_swigt__p_wxMenu,
22128 &_swigt__p_wxMenuBar,
22129 &_swigt__p_wxMenuEvent,
22130 &_swigt__p_wxMenuItem,
22131 &_swigt__p_wxMessageDialog,
22132 &_swigt__p_wxMiniFrame,
22133 &_swigt__p_wxMouseCaptureChangedEvent,
22134 &_swigt__p_wxMouseEvent,
22135 &_swigt__p_wxMoveEvent,
22136 &_swigt__p_wxMultiChoiceDialog,
22137 &_swigt__p_wxNavigationKeyEvent,
22138 &_swigt__p_wxNcPaintEvent,
22139 &_swigt__p_wxNotifyEvent,
22140 &_swigt__p_wxNumberEntryDialog,
22141 &_swigt__p_wxObject,
22142 &_swigt__p_wxPCXHandler,
22143 &_swigt__p_wxPNGHandler,
22144 &_swigt__p_wxPNMHandler,
22145 &_swigt__p_wxPageSetupDialog,
22146 &_swigt__p_wxPageSetupDialogData,
22147 &_swigt__p_wxPaintEvent,
22148 &_swigt__p_wxPaletteChangedEvent,
22149 &_swigt__p_wxPanel,
22150 &_swigt__p_wxPaperSize,
22151 &_swigt__p_wxPasswordEntryDialog,
22152 &_swigt__p_wxPoint,
22153 &_swigt__p_wxPopupWindow,
22154 &_swigt__p_wxPreviewCanvas,
22155 &_swigt__p_wxPreviewControlBar,
22156 &_swigt__p_wxPreviewFrame,
22157 &_swigt__p_wxPrintData,
22158 &_swigt__p_wxPrintDialog,
22159 &_swigt__p_wxPrintDialogData,
22160 &_swigt__p_wxPrintPreview,
22161 &_swigt__p_wxPrinter,
22162 &_swigt__p_wxProgressDialog,
22163 &_swigt__p_wxPyApp,
22164 &_swigt__p_wxPyCommandEvent,
22165 &_swigt__p_wxPyEvent,
22166 &_swigt__p_wxPyGridCellAttrProvider,
22167 &_swigt__p_wxPyGridCellEditor,
22168 &_swigt__p_wxPyGridCellRenderer,
22169 &_swigt__p_wxPyGridTableBase,
22170 &_swigt__p_wxPyHtmlListBox,
22171 &_swigt__p_wxPyImageHandler,
22172 &_swigt__p_wxPyPanel,
22173 &_swigt__p_wxPyPopupTransientWindow,
22174 &_swigt__p_wxPyPreviewControlBar,
22175 &_swigt__p_wxPyPreviewFrame,
22176 &_swigt__p_wxPyPrintPreview,
22177 &_swigt__p_wxPyPrintout,
22178 &_swigt__p_wxPyScrolledWindow,
22179 &_swigt__p_wxPySizer,
22180 &_swigt__p_wxPyTaskBarIcon,
22181 &_swigt__p_wxPyVListBox,
22182 &_swigt__p_wxPyVScrolledWindow,
22183 &_swigt__p_wxPyValidator,
22184 &_swigt__p_wxPyWindow,
22185 &_swigt__p_wxQueryLayoutInfoEvent,
22186 &_swigt__p_wxQueryNewPaletteEvent,
22187 &_swigt__p_wxRect,
22188 &_swigt__p_wxSashEvent,
22189 &_swigt__p_wxSashLayoutWindow,
22190 &_swigt__p_wxSashWindow,
22191 &_swigt__p_wxScrollEvent,
22192 &_swigt__p_wxScrollWinEvent,
22193 &_swigt__p_wxScrolledWindow,
22194 &_swigt__p_wxSetCursorEvent,
22195 &_swigt__p_wxShowEvent,
22196 &_swigt__p_wxSingleChoiceDialog,
22197 &_swigt__p_wxSizeEvent,
22198 &_swigt__p_wxSizer,
22199 &_swigt__p_wxSizerItem,
22200 &_swigt__p_wxSplashScreen,
22201 &_swigt__p_wxSplashScreenWindow,
22202 &_swigt__p_wxSplitterEvent,
22203 &_swigt__p_wxSplitterWindow,
22204 &_swigt__p_wxStaticBoxSizer,
22205 &_swigt__p_wxStatusBar,
22206 &_swigt__p_wxStdDialogButtonSizer,
22207 &_swigt__p_wxString,
22208 &_swigt__p_wxSysColourChangedEvent,
22209 &_swigt__p_wxTIFFHandler,
22210 &_swigt__p_wxTaskBarIconEvent,
22211 &_swigt__p_wxTextEntryDialog,
22212 &_swigt__p_wxTipWindow,
22213 &_swigt__p_wxTopLevelWindow,
22214 &_swigt__p_wxUpdateUIEvent,
22215 &_swigt__p_wxValidator,
22216 &_swigt__p_wxVisualAttributes,
22217 &_swigt__p_wxWindow,
22218 &_swigt__p_wxWindowCreateEvent,
22219 &_swigt__p_wxWindowDestroyEvent,
22220 &_swigt__p_wxXPMHandler,
22221 };
22222
22223 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22224 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22225 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22226 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22227 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22228 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22229 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22230 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22231 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22232 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22233 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22234 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22235 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22236 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22237 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22238 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22239 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22240 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22241 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22242 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22243 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22244 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}};
22245 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22246 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}};
22247 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22248 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22249 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22250 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22251 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22252 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22253 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22254 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22255 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22256 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22257 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22258 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22259 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22260 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22261 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22262 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22263 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22264 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22265 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22266 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22267 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22268 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22269 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22270 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22271 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22272 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22273 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22274 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22275 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22276 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22277 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_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_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_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}};
22278 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22279 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22280 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22281 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22282 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22283 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22284 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22285 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22286 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22287 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22288 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22289 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22290 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22291 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22292 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22293 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22294 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22295 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22296 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22297 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22298 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22299 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22300 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22301 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22302 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22303 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22304 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22305 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22306 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22307 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22308 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22309 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22310 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22311 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22312 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22313 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22314 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22315 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22316 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22317 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22318 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22319 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22320 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22321 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22322 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22323 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}};
22324 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22325 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22326 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22327 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}};
22328 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22329 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22330 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22331 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22332 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}};
22333 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22334 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22335 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}};
22336 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22337 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22338 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22339 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22340 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22341 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22342 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}};
22343 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}};
22344 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}};
22345 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}};
22346 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22351 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}};
22352 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22354 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}};
22355 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22356 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22357 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22358 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22359 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22365 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22366 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22367 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22368 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22375 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22376 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22379 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22380 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22381 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22382 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22383 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22384 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22385 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22386 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22387 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22388 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22389 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22390 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22391 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22393 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22394 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22395 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22396 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22397 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22398 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_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_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_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}};
22399 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}};
22400 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22401 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22402 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22403 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22404 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22405 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22406 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22407 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}};
22408 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22409 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22410 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}};
22411
22412 static swig_cast_info *swig_cast_initial[] = {
22413 _swigc__p_char,
22414 _swigc__p_form_ops_t,
22415 _swigc__p_int,
22416 _swigc__p_long,
22417 _swigc__p_unsigned_char,
22418 _swigc__p_unsigned_int,
22419 _swigc__p_unsigned_long,
22420 _swigc__p_wxANIHandler,
22421 _swigc__p_wxAcceleratorTable,
22422 _swigc__p_wxActivateEvent,
22423 _swigc__p_wxArrayString,
22424 _swigc__p_wxBMPHandler,
22425 _swigc__p_wxBoxSizer,
22426 _swigc__p_wxCURHandler,
22427 _swigc__p_wxCalculateLayoutEvent,
22428 _swigc__p_wxChildFocusEvent,
22429 _swigc__p_wxClipboardTextEvent,
22430 _swigc__p_wxCloseEvent,
22431 _swigc__p_wxColour,
22432 _swigc__p_wxColourData,
22433 _swigc__p_wxColourDialog,
22434 _swigc__p_wxCommandEvent,
22435 _swigc__p_wxContextMenuEvent,
22436 _swigc__p_wxControl,
22437 _swigc__p_wxControlWithItems,
22438 _swigc__p_wxDC,
22439 _swigc__p_wxDateEvent,
22440 _swigc__p_wxDialog,
22441 _swigc__p_wxDirDialog,
22442 _swigc__p_wxDisplayChangedEvent,
22443 _swigc__p_wxDropFilesEvent,
22444 _swigc__p_wxDuplexMode,
22445 _swigc__p_wxEraseEvent,
22446 _swigc__p_wxEvent,
22447 _swigc__p_wxEvtHandler,
22448 _swigc__p_wxFSFile,
22449 _swigc__p_wxFileDialog,
22450 _swigc__p_wxFileSystem,
22451 _swigc__p_wxFindDialogEvent,
22452 _swigc__p_wxFindReplaceData,
22453 _swigc__p_wxFindReplaceDialog,
22454 _swigc__p_wxFlexGridSizer,
22455 _swigc__p_wxFocusEvent,
22456 _swigc__p_wxFont,
22457 _swigc__p_wxFontData,
22458 _swigc__p_wxFontDialog,
22459 _swigc__p_wxFrame,
22460 _swigc__p_wxGBSizerItem,
22461 _swigc__p_wxGIFHandler,
22462 _swigc__p_wxGrid,
22463 _swigc__p_wxGridBagSizer,
22464 _swigc__p_wxGridCellAttr,
22465 _swigc__p_wxGridCellAttrProvider,
22466 _swigc__p_wxGridCellAutoWrapStringEditor,
22467 _swigc__p_wxGridCellAutoWrapStringRenderer,
22468 _swigc__p_wxGridCellBoolEditor,
22469 _swigc__p_wxGridCellBoolRenderer,
22470 _swigc__p_wxGridCellChoiceEditor,
22471 _swigc__p_wxGridCellCoords,
22472 _swigc__p_wxGridCellDateTimeRenderer,
22473 _swigc__p_wxGridCellEditor,
22474 _swigc__p_wxGridCellEnumEditor,
22475 _swigc__p_wxGridCellEnumRenderer,
22476 _swigc__p_wxGridCellFloatEditor,
22477 _swigc__p_wxGridCellFloatRenderer,
22478 _swigc__p_wxGridCellNumberEditor,
22479 _swigc__p_wxGridCellNumberRenderer,
22480 _swigc__p_wxGridCellRenderer,
22481 _swigc__p_wxGridCellStringRenderer,
22482 _swigc__p_wxGridCellTextEditor,
22483 _swigc__p_wxGridCellWorker,
22484 _swigc__p_wxGridEditorCreatedEvent,
22485 _swigc__p_wxGridEvent,
22486 _swigc__p_wxGridRangeSelectEvent,
22487 _swigc__p_wxGridSizeEvent,
22488 _swigc__p_wxGridSizer,
22489 _swigc__p_wxGridStringTable,
22490 _swigc__p_wxGridTableBase,
22491 _swigc__p_wxGridTableMessage,
22492 _swigc__p_wxICOHandler,
22493 _swigc__p_wxIconizeEvent,
22494 _swigc__p_wxIdleEvent,
22495 _swigc__p_wxImage,
22496 _swigc__p_wxImageHandler,
22497 _swigc__p_wxIndividualLayoutConstraint,
22498 _swigc__p_wxInitDialogEvent,
22499 _swigc__p_wxJPEGHandler,
22500 _swigc__p_wxKeyEvent,
22501 _swigc__p_wxLayoutAlgorithm,
22502 _swigc__p_wxLayoutConstraints,
22503 _swigc__p_wxMDIChildFrame,
22504 _swigc__p_wxMDIClientWindow,
22505 _swigc__p_wxMDIParentFrame,
22506 _swigc__p_wxMaximizeEvent,
22507 _swigc__p_wxMenu,
22508 _swigc__p_wxMenuBar,
22509 _swigc__p_wxMenuEvent,
22510 _swigc__p_wxMenuItem,
22511 _swigc__p_wxMessageDialog,
22512 _swigc__p_wxMiniFrame,
22513 _swigc__p_wxMouseCaptureChangedEvent,
22514 _swigc__p_wxMouseEvent,
22515 _swigc__p_wxMoveEvent,
22516 _swigc__p_wxMultiChoiceDialog,
22517 _swigc__p_wxNavigationKeyEvent,
22518 _swigc__p_wxNcPaintEvent,
22519 _swigc__p_wxNotifyEvent,
22520 _swigc__p_wxNumberEntryDialog,
22521 _swigc__p_wxObject,
22522 _swigc__p_wxPCXHandler,
22523 _swigc__p_wxPNGHandler,
22524 _swigc__p_wxPNMHandler,
22525 _swigc__p_wxPageSetupDialog,
22526 _swigc__p_wxPageSetupDialogData,
22527 _swigc__p_wxPaintEvent,
22528 _swigc__p_wxPaletteChangedEvent,
22529 _swigc__p_wxPanel,
22530 _swigc__p_wxPaperSize,
22531 _swigc__p_wxPasswordEntryDialog,
22532 _swigc__p_wxPoint,
22533 _swigc__p_wxPopupWindow,
22534 _swigc__p_wxPreviewCanvas,
22535 _swigc__p_wxPreviewControlBar,
22536 _swigc__p_wxPreviewFrame,
22537 _swigc__p_wxPrintData,
22538 _swigc__p_wxPrintDialog,
22539 _swigc__p_wxPrintDialogData,
22540 _swigc__p_wxPrintPreview,
22541 _swigc__p_wxPrinter,
22542 _swigc__p_wxProgressDialog,
22543 _swigc__p_wxPyApp,
22544 _swigc__p_wxPyCommandEvent,
22545 _swigc__p_wxPyEvent,
22546 _swigc__p_wxPyGridCellAttrProvider,
22547 _swigc__p_wxPyGridCellEditor,
22548 _swigc__p_wxPyGridCellRenderer,
22549 _swigc__p_wxPyGridTableBase,
22550 _swigc__p_wxPyHtmlListBox,
22551 _swigc__p_wxPyImageHandler,
22552 _swigc__p_wxPyPanel,
22553 _swigc__p_wxPyPopupTransientWindow,
22554 _swigc__p_wxPyPreviewControlBar,
22555 _swigc__p_wxPyPreviewFrame,
22556 _swigc__p_wxPyPrintPreview,
22557 _swigc__p_wxPyPrintout,
22558 _swigc__p_wxPyScrolledWindow,
22559 _swigc__p_wxPySizer,
22560 _swigc__p_wxPyTaskBarIcon,
22561 _swigc__p_wxPyVListBox,
22562 _swigc__p_wxPyVScrolledWindow,
22563 _swigc__p_wxPyValidator,
22564 _swigc__p_wxPyWindow,
22565 _swigc__p_wxQueryLayoutInfoEvent,
22566 _swigc__p_wxQueryNewPaletteEvent,
22567 _swigc__p_wxRect,
22568 _swigc__p_wxSashEvent,
22569 _swigc__p_wxSashLayoutWindow,
22570 _swigc__p_wxSashWindow,
22571 _swigc__p_wxScrollEvent,
22572 _swigc__p_wxScrollWinEvent,
22573 _swigc__p_wxScrolledWindow,
22574 _swigc__p_wxSetCursorEvent,
22575 _swigc__p_wxShowEvent,
22576 _swigc__p_wxSingleChoiceDialog,
22577 _swigc__p_wxSizeEvent,
22578 _swigc__p_wxSizer,
22579 _swigc__p_wxSizerItem,
22580 _swigc__p_wxSplashScreen,
22581 _swigc__p_wxSplashScreenWindow,
22582 _swigc__p_wxSplitterEvent,
22583 _swigc__p_wxSplitterWindow,
22584 _swigc__p_wxStaticBoxSizer,
22585 _swigc__p_wxStatusBar,
22586 _swigc__p_wxStdDialogButtonSizer,
22587 _swigc__p_wxString,
22588 _swigc__p_wxSysColourChangedEvent,
22589 _swigc__p_wxTIFFHandler,
22590 _swigc__p_wxTaskBarIconEvent,
22591 _swigc__p_wxTextEntryDialog,
22592 _swigc__p_wxTipWindow,
22593 _swigc__p_wxTopLevelWindow,
22594 _swigc__p_wxUpdateUIEvent,
22595 _swigc__p_wxValidator,
22596 _swigc__p_wxVisualAttributes,
22597 _swigc__p_wxWindow,
22598 _swigc__p_wxWindowCreateEvent,
22599 _swigc__p_wxWindowDestroyEvent,
22600 _swigc__p_wxXPMHandler,
22601 };
22602
22603
22604 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22605
22606 static swig_const_info swig_const_table[] = {
22607 {0, 0, 0, 0.0, 0, 0}};
22608
22609 #ifdef __cplusplus
22610 }
22611 #endif
22612 /* -----------------------------------------------------------------------------
22613 * Type initialization:
22614 * This problem is tough by the requirement that no dynamic
22615 * memory is used. Also, since swig_type_info structures store pointers to
22616 * swig_cast_info structures and swig_cast_info structures store pointers back
22617 * to swig_type_info structures, we need some lookup code at initialization.
22618 * The idea is that swig generates all the structures that are needed.
22619 * The runtime then collects these partially filled structures.
22620 * The SWIG_InitializeModule function takes these initial arrays out of
22621 * swig_module, and does all the lookup, filling in the swig_module.types
22622 * array with the correct data and linking the correct swig_cast_info
22623 * structures together.
22624 *
22625 * The generated swig_type_info structures are assigned staticly to an initial
22626 * array. We just loop though that array, and handle each type individually.
22627 * First we lookup if this type has been already loaded, and if so, use the
22628 * loaded structure instead of the generated one. Then we have to fill in the
22629 * cast linked list. The cast data is initially stored in something like a
22630 * two-dimensional array. Each row corresponds to a type (there are the same
22631 * number of rows as there are in the swig_type_initial array). Each entry in
22632 * a column is one of the swig_cast_info structures for that type.
22633 * The cast_initial array is actually an array of arrays, because each row has
22634 * a variable number of columns. So to actually build the cast linked list,
22635 * we find the array of casts associated with the type, and loop through it
22636 * adding the casts to the list. The one last trick we need to do is making
22637 * sure the type pointer in the swig_cast_info struct is correct.
22638 *
22639 * First off, we lookup the cast->type name to see if it is already loaded.
22640 * There are three cases to handle:
22641 * 1) If the cast->type has already been loaded AND the type we are adding
22642 * casting info to has not been loaded (it is in this module), THEN we
22643 * replace the cast->type pointer with the type pointer that has already
22644 * been loaded.
22645 * 2) If BOTH types (the one we are adding casting info to, and the
22646 * cast->type) are loaded, THEN the cast info has already been loaded by
22647 * the previous module so we just ignore it.
22648 * 3) Finally, if cast->type has not already been loaded, then we add that
22649 * swig_cast_info to the linked list (because the cast->type) pointer will
22650 * be correct.
22651 * ----------------------------------------------------------------------------- */
22652
22653 #ifdef __cplusplus
22654 extern "C" {
22655 #if 0
22656 } /* c-mode */
22657 #endif
22658 #endif
22659
22660 #if 0
22661 #define SWIGRUNTIME_DEBUG
22662 #endif
22663
22664 SWIGRUNTIME void
22665 SWIG_InitializeModule(void *clientdata) {
22666 size_t i;
22667 swig_module_info *module_head;
22668 static int init_run = 0;
22669
22670 clientdata = clientdata;
22671
22672 if (init_run) return;
22673 init_run = 1;
22674
22675 /* Initialize the swig_module */
22676 swig_module.type_initial = swig_type_initial;
22677 swig_module.cast_initial = swig_cast_initial;
22678
22679 /* Try and load any already created modules */
22680 module_head = SWIG_GetModule(clientdata);
22681 if (module_head) {
22682 swig_module.next = module_head->next;
22683 module_head->next = &swig_module;
22684 } else {
22685 /* This is the first module loaded */
22686 swig_module.next = &swig_module;
22687 SWIG_SetModule(clientdata, &swig_module);
22688 }
22689
22690 /* Now work on filling in swig_module.types */
22691 #ifdef SWIGRUNTIME_DEBUG
22692 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22693 #endif
22694 for (i = 0; i < swig_module.size; ++i) {
22695 swig_type_info *type = 0;
22696 swig_type_info *ret;
22697 swig_cast_info *cast;
22698
22699 #ifdef SWIGRUNTIME_DEBUG
22700 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22701 #endif
22702
22703 /* if there is another module already loaded */
22704 if (swig_module.next != &swig_module) {
22705 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22706 }
22707 if (type) {
22708 /* Overwrite clientdata field */
22709 #ifdef SWIGRUNTIME_DEBUG
22710 printf("SWIG_InitializeModule: found type %s\n", type->name);
22711 #endif
22712 if (swig_module.type_initial[i]->clientdata) {
22713 type->clientdata = swig_module.type_initial[i]->clientdata;
22714 #ifdef SWIGRUNTIME_DEBUG
22715 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22716 #endif
22717 }
22718 } else {
22719 type = swig_module.type_initial[i];
22720 }
22721
22722 /* Insert casting types */
22723 cast = swig_module.cast_initial[i];
22724 while (cast->type) {
22725 /* Don't need to add information already in the list */
22726 ret = 0;
22727 #ifdef SWIGRUNTIME_DEBUG
22728 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22729 #endif
22730 if (swig_module.next != &swig_module) {
22731 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22732 #ifdef SWIGRUNTIME_DEBUG
22733 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22734 #endif
22735 }
22736 if (ret) {
22737 if (type == swig_module.type_initial[i]) {
22738 #ifdef SWIGRUNTIME_DEBUG
22739 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22740 #endif
22741 cast->type = ret;
22742 ret = 0;
22743 } else {
22744 /* Check for casting already in the list */
22745 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22746 #ifdef SWIGRUNTIME_DEBUG
22747 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22748 #endif
22749 if (!ocast) ret = 0;
22750 }
22751 }
22752
22753 if (!ret) {
22754 #ifdef SWIGRUNTIME_DEBUG
22755 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22756 #endif
22757 if (type->cast) {
22758 type->cast->prev = cast;
22759 cast->next = type->cast;
22760 }
22761 type->cast = cast;
22762 }
22763 cast++;
22764 }
22765 /* Set entry in modules->types array equal to the type */
22766 swig_module.types[i] = type;
22767 }
22768 swig_module.types[i] = 0;
22769
22770 #ifdef SWIGRUNTIME_DEBUG
22771 printf("**** SWIG_InitializeModule: Cast List ******\n");
22772 for (i = 0; i < swig_module.size; ++i) {
22773 int j = 0;
22774 swig_cast_info *cast = swig_module.cast_initial[i];
22775 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22776 while (cast->type) {
22777 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22778 cast++;
22779 ++j;
22780 }
22781 printf("---- Total casts: %d\n",j);
22782 }
22783 printf("**** SWIG_InitializeModule: Cast List ******\n");
22784 #endif
22785 }
22786
22787 /* This function will propagate the clientdata field of type to
22788 * any new swig_type_info structures that have been added into the list
22789 * of equivalent types. It is like calling
22790 * SWIG_TypeClientData(type, clientdata) a second time.
22791 */
22792 SWIGRUNTIME void
22793 SWIG_PropagateClientData(void) {
22794 size_t i;
22795 swig_cast_info *equiv;
22796 static int init_run = 0;
22797
22798 if (init_run) return;
22799 init_run = 1;
22800
22801 for (i = 0; i < swig_module.size; i++) {
22802 if (swig_module.types[i]->clientdata) {
22803 equiv = swig_module.types[i]->cast;
22804 while (equiv) {
22805 if (!equiv->converter) {
22806 if (equiv->type && !equiv->type->clientdata)
22807 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22808 }
22809 equiv = equiv->next;
22810 }
22811 }
22812 }
22813 }
22814
22815 #ifdef __cplusplus
22816 #if 0
22817 {
22818 /* c-mode */
22819 #endif
22820 }
22821 #endif
22822
22823
22824
22825 #ifdef __cplusplus
22826 extern "C" {
22827 #endif
22828
22829 /* Python-specific SWIG API */
22830 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22831 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22832 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22833
22834 /* -----------------------------------------------------------------------------
22835 * global variable support code.
22836 * ----------------------------------------------------------------------------- */
22837
22838 typedef struct swig_globalvar {
22839 char *name; /* Name of global variable */
22840 PyObject *(*get_attr)(void); /* Return the current value */
22841 int (*set_attr)(PyObject *); /* Set the value */
22842 struct swig_globalvar *next;
22843 } swig_globalvar;
22844
22845 typedef struct swig_varlinkobject {
22846 PyObject_HEAD
22847 swig_globalvar *vars;
22848 } swig_varlinkobject;
22849
22850 SWIGINTERN PyObject *
22851 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22852 return PyString_FromString("<Swig global variables>");
22853 }
22854
22855 SWIGINTERN PyObject *
22856 swig_varlink_str(swig_varlinkobject *v) {
22857 PyObject *str = PyString_FromString("(");
22858 swig_globalvar *var;
22859 for (var = v->vars; var; var=var->next) {
22860 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22861 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22862 }
22863 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22864 return str;
22865 }
22866
22867 SWIGINTERN int
22868 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22869 PyObject *str = swig_varlink_str(v);
22870 fprintf(fp,"Swig global variables ");
22871 fprintf(fp,"%s\n", PyString_AsString(str));
22872 Py_DECREF(str);
22873 return 0;
22874 }
22875
22876 SWIGINTERN void
22877 swig_varlink_dealloc(swig_varlinkobject *v) {
22878 swig_globalvar *var = v->vars;
22879 while (var) {
22880 swig_globalvar *n = var->next;
22881 free(var->name);
22882 free(var);
22883 var = n;
22884 }
22885 }
22886
22887 SWIGINTERN PyObject *
22888 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22889 PyObject *res = NULL;
22890 swig_globalvar *var = v->vars;
22891 while (var) {
22892 if (strcmp(var->name,n) == 0) {
22893 res = (*var->get_attr)();
22894 break;
22895 }
22896 var = var->next;
22897 }
22898 if (res == NULL && !PyErr_Occurred()) {
22899 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22900 }
22901 return res;
22902 }
22903
22904 SWIGINTERN int
22905 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22906 int res = 1;
22907 swig_globalvar *var = v->vars;
22908 while (var) {
22909 if (strcmp(var->name,n) == 0) {
22910 res = (*var->set_attr)(p);
22911 break;
22912 }
22913 var = var->next;
22914 }
22915 if (res == 1 && !PyErr_Occurred()) {
22916 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22917 }
22918 return res;
22919 }
22920
22921 SWIGINTERN PyTypeObject*
22922 swig_varlink_type(void) {
22923 static char varlink__doc__[] = "Swig var link object";
22924 static PyTypeObject varlink_type;
22925 static int type_init = 0;
22926 if (!type_init) {
22927 const PyTypeObject tmp
22928 = {
22929 PyObject_HEAD_INIT(NULL)
22930 0, /* Number of items in variable part (ob_size) */
22931 (char *)"swigvarlink", /* Type name (tp_name) */
22932 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22933 0, /* Itemsize (tp_itemsize) */
22934 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22935 (printfunc) swig_varlink_print, /* Print (tp_print) */
22936 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22937 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22938 0, /* tp_compare */
22939 (reprfunc) swig_varlink_repr, /* tp_repr */
22940 0, /* tp_as_number */
22941 0, /* tp_as_sequence */
22942 0, /* tp_as_mapping */
22943 0, /* tp_hash */
22944 0, /* tp_call */
22945 (reprfunc)swig_varlink_str, /* tp_str */
22946 0, /* tp_getattro */
22947 0, /* tp_setattro */
22948 0, /* tp_as_buffer */
22949 0, /* tp_flags */
22950 varlink__doc__, /* tp_doc */
22951 0, /* tp_traverse */
22952 0, /* tp_clear */
22953 0, /* tp_richcompare */
22954 0, /* tp_weaklistoffset */
22955 #if PY_VERSION_HEX >= 0x02020000
22956 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22957 #endif
22958 #if PY_VERSION_HEX >= 0x02030000
22959 0, /* tp_del */
22960 #endif
22961 #ifdef COUNT_ALLOCS
22962 0,0,0,0 /* tp_alloc -> tp_next */
22963 #endif
22964 };
22965 varlink_type = tmp;
22966 varlink_type.ob_type = &PyType_Type;
22967 type_init = 1;
22968 }
22969 return &varlink_type;
22970 }
22971
22972 /* Create a variable linking object for use later */
22973 SWIGINTERN PyObject *
22974 SWIG_Python_newvarlink(void) {
22975 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22976 if (result) {
22977 result->vars = 0;
22978 }
22979 return ((PyObject*) result);
22980 }
22981
22982 SWIGINTERN void
22983 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22984 swig_varlinkobject *v = (swig_varlinkobject *) p;
22985 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22986 if (gv) {
22987 size_t size = strlen(name)+1;
22988 gv->name = (char *)malloc(size);
22989 if (gv->name) {
22990 strncpy(gv->name,name,size);
22991 gv->get_attr = get_attr;
22992 gv->set_attr = set_attr;
22993 gv->next = v->vars;
22994 }
22995 }
22996 v->vars = gv;
22997 }
22998
22999 SWIGINTERN PyObject *
23000 SWIG_globals() {
23001 static PyObject *_SWIG_globals = 0;
23002 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23003 return _SWIG_globals;
23004 }
23005
23006 /* -----------------------------------------------------------------------------
23007 * constants/methods manipulation
23008 * ----------------------------------------------------------------------------- */
23009
23010 /* Install Constants */
23011 SWIGINTERN void
23012 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23013 PyObject *obj = 0;
23014 size_t i;
23015 for (i = 0; constants[i].type; ++i) {
23016 switch(constants[i].type) {
23017 case SWIG_PY_POINTER:
23018 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23019 break;
23020 case SWIG_PY_BINARY:
23021 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23022 break;
23023 default:
23024 obj = 0;
23025 break;
23026 }
23027 if (obj) {
23028 PyDict_SetItemString(d, constants[i].name, obj);
23029 Py_DECREF(obj);
23030 }
23031 }
23032 }
23033
23034 /* -----------------------------------------------------------------------------*/
23035 /* Fix SwigMethods to carry the callback ptrs when needed */
23036 /* -----------------------------------------------------------------------------*/
23037
23038 SWIGINTERN void
23039 SWIG_Python_FixMethods(PyMethodDef *methods,
23040 swig_const_info *const_table,
23041 swig_type_info **types,
23042 swig_type_info **types_initial) {
23043 size_t i;
23044 for (i = 0; methods[i].ml_name; ++i) {
23045 const char *c = methods[i].ml_doc;
23046 if (c && (c = strstr(c, "swig_ptr: "))) {
23047 int j;
23048 swig_const_info *ci = 0;
23049 const char *name = c + 10;
23050 for (j = 0; const_table[j].type; ++j) {
23051 if (strncmp(const_table[j].name, name,
23052 strlen(const_table[j].name)) == 0) {
23053 ci = &(const_table[j]);
23054 break;
23055 }
23056 }
23057 if (ci) {
23058 size_t shift = (ci->ptype) - types;
23059 swig_type_info *ty = types_initial[shift];
23060 size_t ldoc = (c - methods[i].ml_doc);
23061 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23062 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23063 if (ndoc) {
23064 char *buff = ndoc;
23065 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23066 if (ptr) {
23067 strncpy(buff, methods[i].ml_doc, ldoc);
23068 buff += ldoc;
23069 strncpy(buff, "swig_ptr: ", 10);
23070 buff += 10;
23071 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23072 methods[i].ml_doc = ndoc;
23073 }
23074 }
23075 }
23076 }
23077 }
23078 }
23079
23080 #ifdef __cplusplus
23081 }
23082 #endif
23083
23084 /* -----------------------------------------------------------------------------*
23085 * Partial Init method
23086 * -----------------------------------------------------------------------------*/
23087
23088 #ifdef __cplusplus
23089 extern "C"
23090 #endif
23091 SWIGEXPORT void SWIG_init(void) {
23092 PyObject *m, *d;
23093
23094 /* Fix SwigMethods to carry the callback ptrs when needed */
23095 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23096
23097 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23098 d = PyModule_GetDict(m);
23099
23100 SWIG_InitializeModule(0);
23101 SWIG_InstallConstants(d,swig_const_table);
23102
23103
23104 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23105 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23106 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23107 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23108 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23109 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23110 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23111 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23112 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23113 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23114 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23115 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23116 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23117 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23118 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23119 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23120 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23121 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23122 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23123 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23124 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23125 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23126 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23127 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23128 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23129 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23130 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23131 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23132 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23133 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23134 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23135 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23136 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23137 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23138 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23139 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23140 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23141 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23142 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23143 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23144 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23145 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23146 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23147 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23148 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23149 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23150 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23151 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23152 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23153 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23154 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23155 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23156 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23157 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23158 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23159 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23160
23161
23162 }
23163
wxWidgets (Impactor)