]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
deprecated wxString::GetWriteBuf() and friends in favour of wxStringBuffer
[wxWidgets.git] / wxPython / src / mac / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEventBlocker swig_types[34]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[35]
2502 #define SWIGTYPE_p_wxFSFile swig_types[36]
2503 #define SWIGTYPE_p_wxFileDialog swig_types[37]
2504 #define SWIGTYPE_p_wxFileSystem swig_types[38]
2505 #define SWIGTYPE_p_wxFindDialogEvent swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceData swig_types[40]
2507 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[41]
2508 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2509 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2510 #define SWIGTYPE_p_wxFont swig_types[44]
2511 #define SWIGTYPE_p_wxFontData swig_types[45]
2512 #define SWIGTYPE_p_wxFontDialog swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2516 #define SWIGTYPE_p_wxGrid swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttr swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellCoords swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[70]
2537 #define SWIGTYPE_p_wxGridCellWorker swig_types[71]
2538 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizeEvent swig_types[75]
2542 #define SWIGTYPE_p_wxGridSizer swig_types[76]
2543 #define SWIGTYPE_p_wxGridStringTable swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableBase swig_types[78]
2545 #define SWIGTYPE_p_wxGridTableMessage swig_types[79]
2546 #define SWIGTYPE_p_wxICOHandler swig_types[80]
2547 #define SWIGTYPE_p_wxIconizeEvent swig_types[81]
2548 #define SWIGTYPE_p_wxIdleEvent swig_types[82]
2549 #define SWIGTYPE_p_wxImage swig_types[83]
2550 #define SWIGTYPE_p_wxImageHandler swig_types[84]
2551 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[85]
2552 #define SWIGTYPE_p_wxInitDialogEvent swig_types[86]
2553 #define SWIGTYPE_p_wxJPEGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxKeyEvent swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[89]
2556 #define SWIGTYPE_p_wxLayoutConstraints swig_types[90]
2557 #define SWIGTYPE_p_wxMDIChildFrame swig_types[91]
2558 #define SWIGTYPE_p_wxMDIClientWindow swig_types[92]
2559 #define SWIGTYPE_p_wxMDIParentFrame swig_types[93]
2560 #define SWIGTYPE_p_wxMaximizeEvent swig_types[94]
2561 #define SWIGTYPE_p_wxMenu swig_types[95]
2562 #define SWIGTYPE_p_wxMenuBar swig_types[96]
2563 #define SWIGTYPE_p_wxMenuEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMenuItem swig_types[98]
2565 #define SWIGTYPE_p_wxMessageDialog swig_types[99]
2566 #define SWIGTYPE_p_wxMiniFrame swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMoveEvent swig_types[104]
2571 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[105]
2572 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNcPaintEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNotifyEvent swig_types[108]
2575 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[109]
2576 #define SWIGTYPE_p_wxObject swig_types[110]
2577 #define SWIGTYPE_p_wxPCXHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNGHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNMHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialog swig_types[114]
2581 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[115]
2582 #define SWIGTYPE_p_wxPaintEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPanel swig_types[118]
2585 #define SWIGTYPE_p_wxPaperSize swig_types[119]
2586 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[120]
2587 #define SWIGTYPE_p_wxPen swig_types[121]
2588 #define SWIGTYPE_p_wxPoint swig_types[122]
2589 #define SWIGTYPE_p_wxPopupWindow swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewCanvas swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewControlBar swig_types[125]
2592 #define SWIGTYPE_p_wxPreviewFrame swig_types[126]
2593 #define SWIGTYPE_p_wxPrintData swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialog swig_types[128]
2595 #define SWIGTYPE_p_wxPrintDialogData swig_types[129]
2596 #define SWIGTYPE_p_wxPrintPreview swig_types[130]
2597 #define SWIGTYPE_p_wxPrinter swig_types[131]
2598 #define SWIGTYPE_p_wxProgressDialog swig_types[132]
2599 #define SWIGTYPE_p_wxPyApp swig_types[133]
2600 #define SWIGTYPE_p_wxPyCommandEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[138]
2605 #define SWIGTYPE_p_wxPyGridTableBase swig_types[139]
2606 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[140]
2607 #define SWIGTYPE_p_wxPyImageHandler swig_types[141]
2608 #define SWIGTYPE_p_wxPyPanel swig_types[142]
2609 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[144]
2611 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintPreview swig_types[146]
2613 #define SWIGTYPE_p_wxPyPrintout swig_types[147]
2614 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[148]
2615 #define SWIGTYPE_p_wxPySizer swig_types[149]
2616 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[150]
2617 #define SWIGTYPE_p_wxPyVListBox swig_types[151]
2618 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[152]
2619 #define SWIGTYPE_p_wxPyValidator swig_types[153]
2620 #define SWIGTYPE_p_wxPyWindow swig_types[154]
2621 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[155]
2622 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[156]
2623 #define SWIGTYPE_p_wxRect swig_types[157]
2624 #define SWIGTYPE_p_wxSashEvent swig_types[158]
2625 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[159]
2626 #define SWIGTYPE_p_wxSashWindow swig_types[160]
2627 #define SWIGTYPE_p_wxScrollEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrollWinEvent swig_types[162]
2629 #define SWIGTYPE_p_wxScrolledWindow swig_types[163]
2630 #define SWIGTYPE_p_wxSetCursorEvent swig_types[164]
2631 #define SWIGTYPE_p_wxShowEvent swig_types[165]
2632 #define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[166]
2633 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[167]
2634 #define SWIGTYPE_p_wxSize swig_types[168]
2635 #define SWIGTYPE_p_wxSizeEvent swig_types[169]
2636 #define SWIGTYPE_p_wxSizer swig_types[170]
2637 #define SWIGTYPE_p_wxSizerItem swig_types[171]
2638 #define SWIGTYPE_p_wxSplashScreen swig_types[172]
2639 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[173]
2640 #define SWIGTYPE_p_wxSplitterEvent swig_types[174]
2641 #define SWIGTYPE_p_wxSplitterWindow swig_types[175]
2642 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[176]
2643 #define SWIGTYPE_p_wxStatusBar swig_types[177]
2644 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[178]
2645 #define SWIGTYPE_p_wxString swig_types[179]
2646 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[180]
2647 #define SWIGTYPE_p_wxTGAHandler swig_types[181]
2648 #define SWIGTYPE_p_wxTIFFHandler swig_types[182]
2649 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[183]
2650 #define SWIGTYPE_p_wxTextEntryDialog swig_types[184]
2651 #define SWIGTYPE_p_wxTipWindow swig_types[185]
2652 #define SWIGTYPE_p_wxTopLevelWindow swig_types[186]
2653 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[187]
2654 #define SWIGTYPE_p_wxValidator swig_types[188]
2655 #define SWIGTYPE_p_wxVisualAttributes swig_types[189]
2656 #define SWIGTYPE_p_wxWindow swig_types[190]
2657 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[191]
2658 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[192]
2659 #define SWIGTYPE_p_wxXPMHandler swig_types[193]
2660 static swig_type_info *swig_types[195];
2661 static swig_module_info swig_module = {swig_types, 194, 0, 0, 0, 0};
2662 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2663 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2664
2665 /* -------- TYPES TABLE (END) -------- */
2666
2667 #if (PY_VERSION_HEX <= 0x02000000)
2668 # if !defined(SWIG_PYTHON_CLASSIC)
2669 # error "This python version requires to use swig with the '-classic' option"
2670 # endif
2671 #endif
2672 #if (PY_VERSION_HEX <= 0x02020000)
2673 # error "This python version requires to use swig with the '-nomodern' option"
2674 #endif
2675 #if (PY_VERSION_HEX <= 0x02020000)
2676 # error "This python version requires to use swig with the '-nomodernargs' option"
2677 #endif
2678 #ifndef METH_O
2679 # error "This python version requires to use swig with the '-nofastunpack' option"
2680 #endif
2681
2682 /*-----------------------------------------------
2683 @(target):= _grid.so
2684 ------------------------------------------------*/
2685 #define SWIG_init init_grid
2686
2687 #define SWIG_name "_grid"
2688
2689 #define SWIGVERSION 0x010329
2690
2691
2692 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2693 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2694
2695
2696 #include <stdexcept>
2697
2698
2699 namespace swig {
2700 class PyObject_ptr {
2701 protected:
2702 PyObject *_obj;
2703
2704 public:
2705 PyObject_ptr() :_obj(0)
2706 {
2707 }
2708
2709 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2710 {
2711 Py_XINCREF(_obj);
2712 }
2713
2714 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2715 {
2716 if (initial_ref) Py_XINCREF(_obj);
2717 }
2718
2719 PyObject_ptr & operator=(const PyObject_ptr& item)
2720 {
2721 Py_XINCREF(item._obj);
2722 Py_XDECREF(_obj);
2723 _obj = item._obj;
2724 return *this;
2725 }
2726
2727 ~PyObject_ptr()
2728 {
2729 Py_XDECREF(_obj);
2730 }
2731
2732 operator PyObject *() const
2733 {
2734 return _obj;
2735 }
2736
2737 PyObject *operator->() const
2738 {
2739 return _obj;
2740 }
2741 };
2742 }
2743
2744
2745 namespace swig {
2746 struct PyObject_var : PyObject_ptr {
2747 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2748
2749 PyObject_var & operator = (PyObject* obj)
2750 {
2751 Py_XDECREF(_obj);
2752 _obj = obj;
2753 return *this;
2754 }
2755 };
2756 }
2757
2758
2759 #include "wx/wxPython/wxPython.h"
2760 #include "wx/wxPython/pyclasses.h"
2761 #include "wx/wxPython/printfw.h"
2762
2763 #include <wx/grid.h>
2764 #include <wx/generic/gridctrl.h>
2765
2766
2767 static const wxString wxPyEmptyString(wxEmptyString);
2768 static const wxString wxPyGridNameStr(wxGridNameStr);
2769 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2770
2771
2772 #define wxPyMake_TEMPLATE(TYPE) \
2773 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2774 PyObject* target = NULL; \
2775 if (source) { \
2776 /* Check if there is already a pointer to a Python object in the \
2777 OOR data that we can use. */ \
2778 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2779 if (data) { \
2780 target = data->m_obj; \
2781 if (target) \
2782 Py_INCREF(target); \
2783 } \
2784 /* Otherwise make a new wrapper for it the old fashioned way and \
2785 give it the OOR treatment */ \
2786 if (! target) { \
2787 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2788 if (target) \
2789 source->SetClientObject(new wxPyOORClientData(target)); \
2790 } \
2791 } else { /* source was NULL so return None. */ \
2792 Py_INCREF(Py_None); target = Py_None; \
2793 } \
2794 return target; \
2795 } \
2796
2797
2798 wxPyMake_TEMPLATE(wxGridCellRenderer)
2799 wxPyMake_TEMPLATE(wxGridCellEditor)
2800 wxPyMake_TEMPLATE(wxGridCellAttr)
2801 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2802 wxPyMake_TEMPLATE(wxGridTableBase)
2803
2804
2805
2806 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2807 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2808 wxGridCellAttr* rval = NULL; \
2809 bool found; \
2810 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2811 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2812 PyObject* ro; \
2813 wxGridCellAttr* ptr; \
2814 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2815 if (ro) { \
2816 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2817 rval = ptr; \
2818 Py_DECREF(ro); \
2819 } \
2820 } \
2821 wxPyEndBlockThreads(blocked); \
2822 if (! found) \
2823 rval = PCLASS::CBNAME(a, b, c); \
2824 return rval; \
2825 }
2826
2827
2828 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2829 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2830 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2831 bool found; \
2832 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2833 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2834 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2835 Py_DECREF(obj); \
2836 } \
2837 wxPyEndBlockThreads(blocked); \
2838 if (! found) \
2839 PCLASS::CBNAME(attr, a, b); \
2840 }
2841
2842
2843
2844 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2845 void CBNAME(wxGridCellAttr *attr, int val) { \
2846 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2847 bool found; \
2848 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2849 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2850 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2851 Py_DECREF(obj); \
2852 } \
2853 wxPyEndBlockThreads(blocked); \
2854 if (! found) \
2855 PCLASS::CBNAME(attr, val); \
2856 }
2857
2858
2859
2860 #define PYCALLBACK_INT__pure(CBNAME) \
2861 int CBNAME() { \
2862 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2863 int rval = 0; \
2864 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2865 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2866 wxPyEndBlockThreads(blocked); \
2867 return rval; \
2868 }
2869
2870
2871
2872 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2873 bool CBNAME(int a, int b) { \
2874 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2875 bool rval = 0; \
2876 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2877 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2878 wxPyEndBlockThreads(blocked); \
2879 return rval; \
2880 }
2881
2882
2883 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2884 wxString CBNAME(int a, int b) { \
2885 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2886 wxString rval; \
2887 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2888 PyObject* ro; \
2889 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2890 if (ro) { \
2891 rval = Py2wxString(ro); \
2892 Py_DECREF(ro); \
2893 } \
2894 } \
2895 wxPyEndBlockThreads(blocked); \
2896 return rval; \
2897 }
2898
2899
2900 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2901 void CBNAME(int a, int b, const wxString& c) { \
2902 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2903 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2904 PyObject* s = wx2PyString(c); \
2905 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2906 Py_DECREF(s); \
2907 } \
2908 wxPyEndBlockThreads(blocked); \
2909 }
2910
2911
2912 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2913 wxString CBNAME(int a, int b) { \
2914 bool found; \
2915 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2916 wxString rval; \
2917 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2918 PyObject* ro; \
2919 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2920 if (ro) { \
2921 rval = Py2wxString(ro); \
2922 Py_DECREF(ro); \
2923 } \
2924 } \
2925 wxPyEndBlockThreads(blocked); \
2926 if (! found) \
2927 rval = PCLASS::CBNAME(a, b); \
2928 return rval; \
2929 }
2930
2931
2932 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2933 bool CBNAME(int a, int b, const wxString& c) { \
2934 bool rval = 0; \
2935 bool found; \
2936 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2937 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2938 PyObject* s = wx2PyString(c); \
2939 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2940 Py_DECREF(s); \
2941 } \
2942 wxPyEndBlockThreads(blocked); \
2943 if (! found) \
2944 rval = PCLASS::CBNAME(a,b,c); \
2945 return rval; \
2946 }
2947
2948
2949
2950
2951 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2952 long CBNAME(int a, int b) { \
2953 long rval; \
2954 bool found; \
2955 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2956 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2957 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2958 wxPyEndBlockThreads(blocked); \
2959 if (! found) \
2960 rval = PCLASS::CBNAME(a,b); \
2961 return rval; \
2962 }
2963
2964
2965 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2966 bool CBNAME(int a, int b) { \
2967 bool rval = 0; \
2968 bool found; \
2969 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2970 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2971 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2972 wxPyEndBlockThreads(blocked); \
2973 if (! found) \
2974 rval = PCLASS::CBNAME(a,b); \
2975 return rval; \
2976 }
2977
2978
2979
2980 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2981 double CBNAME(int a, int b) { \
2982 bool found; \
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2984 double rval; \
2985 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2986 PyObject* ro; \
2987 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2988 if (ro) { \
2989 PyObject* str = PyObject_Str(ro); \
2990 rval = PyFloat_AsDouble(str); \
2991 Py_DECREF(ro); Py_DECREF(str); \
2992 } \
2993 } \
2994 wxPyEndBlockThreads(blocked); \
2995 if (! found) \
2996 rval = PCLASS::CBNAME(a, b); \
2997 return rval; \
2998 }
2999
3000
3001
3002 #define PYCALLBACK__(PCLASS, CBNAME) \
3003 void CBNAME() { \
3004 bool found; \
3005 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3006 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3007 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3008 wxPyEndBlockThreads(blocked); \
3009 if (! found) \
3010 PCLASS::CBNAME(); \
3011 }
3012
3013
3014
3015 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3016 bool CBNAME(size_t a, size_t b) { \
3017 bool rval = 0; \
3018 bool found; \
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3020 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3021 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3022 wxPyEndBlockThreads(blocked); \
3023 if (! found) \
3024 rval = PCLASS::CBNAME(a,b); \
3025 return rval; \
3026 }
3027
3028
3029
3030 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3031 bool CBNAME(size_t a) { \
3032 bool rval = 0; \
3033 bool found; \
3034 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3035 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3036 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3037 wxPyEndBlockThreads(blocked); \
3038 if (! found) \
3039 rval = PCLASS::CBNAME(a); \
3040 return rval; \
3041 }
3042
3043
3044 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3045 wxString CBNAME(int a) { \
3046 bool found; \
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3048 wxString rval; \
3049 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3050 PyObject* ro; \
3051 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3052 if (ro) { \
3053 rval = Py2wxString(ro); \
3054 Py_DECREF(ro); \
3055 } \
3056 } \
3057 wxPyEndBlockThreads(blocked); \
3058 if (! found) \
3059 rval = PCLASS::CBNAME(a); \
3060 return rval; \
3061 }
3062
3063
3064 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3065 void CBNAME(int a, const wxString& c) { \
3066 bool found; \
3067 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3068 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3069 PyObject* s = wx2PyString(c); \
3070 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3071 Py_DECREF(s); \
3072 } \
3073 wxPyEndBlockThreads(blocked); \
3074 if (! found) \
3075 PCLASS::CBNAME(a,c); \
3076 }
3077
3078
3079
3080
3081 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3082 bool CBNAME() { \
3083 bool rval = 0; \
3084 bool found; \
3085 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3086 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3087 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3088 wxPyEndBlockThreads(blocked); \
3089 if (! found) \
3090 rval = PCLASS::CBNAME(); \
3091 return rval; \
3092 }
3093
3094
3095
3096 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3097 void CBNAME(size_t a, int b) { \
3098 bool found; \
3099 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3100 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3101 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3102 wxPyEndBlockThreads(blocked); \
3103 if (! found) \
3104 PCLASS::CBNAME(a,b); \
3105 }
3106
3107
3108
3109
3110 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3111 void CBNAME(int a, int b, long c) { \
3112 bool found; \
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3114 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3115 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3116 wxPyEndBlockThreads(blocked); \
3117 if (! found) \
3118 PCLASS::CBNAME(a,b,c); \
3119 }
3120
3121
3122
3123
3124 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3125 void CBNAME(int a, int b, double c) { \
3126 bool found; \
3127 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3128 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3129 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3130 wxPyEndBlockThreads(blocked); \
3131 if (! found) \
3132 PCLASS::CBNAME(a,b,c); \
3133 }
3134
3135
3136
3137 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3138 void CBNAME(int a, int b, bool c) { \
3139 bool found; \
3140 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3141 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3142 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3143 wxPyEndBlockThreads(blocked); \
3144 if (! found) \
3145 PCLASS::CBNAME(a,b,c); \
3146 }
3147
3148
3149
3150
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_FromCharPtr(const char *cptr)
3184 {
3185 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3186 }
3187
3188
3189 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3190 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3191 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3192 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3193 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3194 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3195 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3196 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3197 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3198 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3199
3200
3201 #define SWIG_From_long PyInt_FromLong
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_int (int value)
3206 {
3207 return SWIG_From_long (value);
3208 }
3209
3210 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3211 if (!self->GetClientObject())
3212 self->SetClientObject(new wxPyOORClientData(_self));
3213 }
3214 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3215 }
3216
3217 #include <limits.h>
3218 #ifndef LLONG_MIN
3219 # define LLONG_MIN LONG_LONG_MIN
3220 #endif
3221 #ifndef LLONG_MAX
3222 # define LLONG_MAX LONG_LONG_MAX
3223 #endif
3224 #ifndef ULLONG_MAX
3225 # define ULLONG_MAX ULONG_LONG_MAX
3226 #endif
3227
3228
3229 SWIGINTERN int
3230 SWIG_AsVal_long (PyObject* obj, long* val)
3231 {
3232 if (PyNumber_Check(obj)) {
3233 if (val) *val = PyInt_AsLong(obj);
3234 return SWIG_OK;
3235 }
3236 return SWIG_TypeError;
3237 }
3238
3239
3240 SWIGINTERN int
3241 SWIG_AsVal_int (PyObject * obj, int *val)
3242 {
3243 long v;
3244 int res = SWIG_AsVal_long (obj, &v);
3245 if (SWIG_IsOK(res)) {
3246 if ((v < INT_MIN || v > INT_MAX)) {
3247 return SWIG_OverflowError;
3248 } else {
3249 if (val) *val = static_cast< int >(v);
3250 }
3251 }
3252 return res;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsVal_bool (PyObject *obj, bool *val)
3258 {
3259 if (obj == Py_True) {
3260 if (val) *val = true;
3261 return SWIG_OK;
3262 } else if (obj == Py_False) {
3263 if (val) *val = false;
3264 return SWIG_OK;
3265 } else {
3266 long v = 0;
3267 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3268 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3269 return res;
3270 }
3271 }
3272
3273
3274 class wxPyGridCellRenderer : public wxGridCellRenderer
3275 {
3276 public:
3277 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3278
3279 // Implement Python callback aware virtual methods
3280 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3281 wxDC& dc, const wxRect& rect,
3282 int row, int col, bool isSelected) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3285 PyObject* go = wxPyMake_wxObject(&grid,false);
3286 PyObject* dco = wxPyMake_wxObject(&dc,false);
3287 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3288 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3289
3290 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3291 row, col, isSelected));
3292 Py_DECREF(go);
3293 Py_DECREF(ao);
3294 Py_DECREF(dco);
3295 Py_DECREF(ro);
3296 }
3297 wxPyEndBlockThreads(blocked);
3298 }
3299
3300 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3301 int row, int col) {
3302 wxSize rval;
3303 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3304 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3305 PyObject* ro;
3306 wxSize* ptr;
3307 PyObject* go = wxPyMake_wxObject(&grid,false);
3308 PyObject* dco = wxPyMake_wxObject(&dc,false);
3309 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3310
3311 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3312 go, ao, dco,
3313 row, col));
3314 Py_DECREF(go);
3315 Py_DECREF(ao);
3316 Py_DECREF(dco);
3317
3318 if (ro) {
3319 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3320 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3321 rval = *ptr;
3322 }
3323 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3324 PyErr_Clear(); // Clear the exception left over from wxPyConvertSwigPtr
3325 PyObject* o1 = PySequence_GetItem(ro, 0);
3326 PyObject* o2 = PySequence_GetItem(ro, 1);
3327 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3328 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3329 else
3330 PyErr_SetString(PyExc_TypeError, errmsg);
3331 Py_DECREF(o1);
3332 Py_DECREF(o2);
3333 }
3334 else {
3335 PyErr_SetString(PyExc_TypeError, errmsg);
3336 }
3337 Py_DECREF(ro);
3338 }
3339 }
3340 wxPyEndBlockThreads(blocked);
3341 return rval;
3342 }
3343
3344
3345 wxGridCellRenderer *Clone() const {
3346 wxGridCellRenderer* rval = NULL;
3347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3348 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3349 PyObject* ro;
3350 wxGridCellRenderer* ptr;
3351 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3352 if (ro) {
3353 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3354 rval = ptr;
3355 Py_DECREF(ro);
3356 }
3357 }
3358 wxPyEndBlockThreads(blocked);
3359 return rval;
3360 }
3361
3362 DEC_PYCALLBACK__STRING(SetParameters);
3363
3364 PYPRIVATE;
3365 };
3366
3367 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3368
3369
3370
3371 class wxPyGridCellEditor : public wxGridCellEditor
3372 {
3373 public:
3374 wxPyGridCellEditor() : wxGridCellEditor() {}
3375
3376 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3377 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3378 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3379 PyObject* po = wxPyMake_wxObject(parent,false);
3380 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3381
3382 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3383 Py_DECREF(po);
3384 Py_DECREF(eo);
3385 }
3386 wxPyEndBlockThreads(blocked);
3387 }
3388
3389
3390 void BeginEdit(int row, int col, wxGrid* grid) {
3391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3392 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3393 PyObject* go = wxPyMake_wxObject(grid,false);
3394 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3395 Py_DECREF(go);
3396 }
3397 wxPyEndBlockThreads(blocked);
3398 }
3399
3400
3401 bool EndEdit(int row, int col, wxGrid* grid) {
3402 bool rv = false;
3403 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3404 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3405 PyObject* go = wxPyMake_wxObject(grid,false);
3406 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3407 Py_DECREF(go);
3408 }
3409 wxPyEndBlockThreads(blocked);
3410 return rv;
3411 }
3412
3413
3414 wxGridCellEditor* Clone() const {
3415 wxGridCellEditor* rval = NULL;
3416 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3417 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3418 PyObject* ro;
3419 wxGridCellEditor* ptr;
3420 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3421 if (ro) {
3422 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3423 rval = ptr;
3424 Py_DECREF(ro);
3425 }
3426 }
3427 wxPyEndBlockThreads(blocked);
3428 return rval;
3429 }
3430
3431
3432 void Show(bool show, wxGridCellAttr *attr) {
3433 bool found;
3434 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3435 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3436 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3437 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3438 Py_DECREF(ao);
3439 }
3440 wxPyEndBlockThreads(blocked);
3441 if (! found)
3442 wxGridCellEditor::Show(show, attr);
3443 }
3444
3445
3446 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3447 bool found;
3448 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3449 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3450 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3451 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3452
3453 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3454
3455 Py_DECREF(ro);
3456 Py_DECREF(ao);
3457 }
3458 wxPyEndBlockThreads(blocked);
3459 if (! found)
3460 wxGridCellEditor::PaintBackground(rectCell, attr);
3461 }
3462
3463
3464 DEC_PYCALLBACK___pure(Reset);
3465 DEC_PYCALLBACK__constany(SetSize, wxRect);
3466 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3467 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3468 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3469 DEC_PYCALLBACK__(StartingClick);
3470 DEC_PYCALLBACK__(Destroy);
3471 DEC_PYCALLBACK__STRING(SetParameters);
3472 DEC_PYCALLBACK_STRING__constpure(GetValue);
3473
3474 PYPRIVATE;
3475 };
3476
3477
3478 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3479 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3480 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3481 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3482 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3483 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3484 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3485 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3486 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3487
3488
3489 static const wxString wxPyOneString(_T("1"));
3490 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3491 if (!self->GetClientObject())
3492 self->SetClientObject(new wxPyOORClientData(_self));
3493 }
3494 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3495 }
3496 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3497 if (!self->GetClientObject())
3498 self->SetClientObject(new wxPyOORClientData(_self));
3499 }
3500
3501 SWIGINTERN int
3502 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3503 {
3504 long v = 0;
3505 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3506 return SWIG_TypeError;
3507 }
3508 else if (val)
3509 *val = (unsigned long)v;
3510 return SWIG_OK;
3511 }
3512
3513
3514 SWIGINTERNINLINE int
3515 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3516 {
3517 unsigned long v;
3518 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3519 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3520 return res;
3521 }
3522
3523
3524 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3525 {
3526 public:
3527 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3528
3529 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3530 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3531 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3532 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3538 if (!self->GetClientObject())
3539 self->SetClientObject(new wxPyOORClientData(_self));
3540 }
3541
3542 #define SWIG_From_double PyFloat_FromDouble
3543
3544
3545 SWIGINTERN int
3546 SWIG_AsVal_double (PyObject *obj, double* val)
3547 {
3548 if (PyNumber_Check(obj)) {
3549 if (val) *val = PyFloat_AsDouble(obj);
3550 return SWIG_OK;
3551 }
3552 return SWIG_TypeError;
3553 }
3554
3555
3556 class wxPyGridTableBase : public wxGridTableBase
3557 {
3558 public:
3559 wxPyGridTableBase() : wxGridTableBase() {}
3560
3561 PYCALLBACK_INT__pure(GetNumberRows);
3562 PYCALLBACK_INT__pure(GetNumberCols);
3563 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3564 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3565 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3566 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3567 PYCALLBACK__(wxGridTableBase, Clear);
3568 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3569 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3570 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3571 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3572 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3573 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3574 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3575 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3576 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3577 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3578 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3579 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3580 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3581 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3582 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3583
3584
3585 wxString GetValue(int row, int col) {
3586 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3587 wxString rval;
3588 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3589 PyObject* ro;
3590 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3591 if (ro) {
3592 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3593 PyObject* old = ro;
3594 ro = PyObject_Str(ro);
3595 Py_DECREF(old);
3596 }
3597 rval = Py2wxString(ro);
3598 Py_DECREF(ro);
3599 }
3600 }
3601 wxPyEndBlockThreads(blocked);
3602 return rval;
3603 }
3604
3605 void SetValue(int row, int col, const wxString& val) {
3606 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3607 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3608 PyObject* s = wx2PyString(val);
3609 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3610 Py_DECREF(s);
3611 }
3612 wxPyEndBlockThreads(blocked);
3613 }
3614
3615
3616 // Map the Get/Set methods for the standard non-string types to
3617 // the GetValue and SetValue python methods.
3618 long GetValueAsLong( int row, int col ) {
3619 long rval = 0;
3620 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3621 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3622 PyObject* ro;
3623 PyObject* num;
3624 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3625 if (ro && PyNumber_Check(ro)) {
3626 num = PyNumber_Int(ro);
3627 if (num) {
3628 rval = PyInt_AsLong(num);
3629 Py_DECREF(num);
3630 }
3631 Py_DECREF(ro);
3632 }
3633 }
3634 wxPyEndBlockThreads(blocked);
3635 return rval;
3636 }
3637
3638 double GetValueAsDouble( int row, int col ) {
3639 double rval = 0.0;
3640 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3641 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3642 PyObject* ro;
3643 PyObject* num;
3644 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3645 if (ro && PyNumber_Check(ro)) {
3646 num = PyNumber_Float(ro);
3647 if (num) {
3648 rval = PyFloat_AsDouble(num);
3649 Py_DECREF(num);
3650 }
3651 Py_DECREF(ro);
3652 }
3653 }
3654 wxPyEndBlockThreads(blocked);
3655 return rval;
3656 }
3657
3658 bool GetValueAsBool( int row, int col ) {
3659 return (bool)GetValueAsLong(row, col);
3660 }
3661
3662 void SetValueAsLong( int row, int col, long value ) {
3663 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3664 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3665 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3666 }
3667 wxPyEndBlockThreads(blocked);
3668 }
3669
3670 void SetValueAsDouble( int row, int col, double value ) {
3671 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3672 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3673 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3674 }
3675 wxPyEndBlockThreads(blocked);
3676 }
3677
3678 void SetValueAsBool( int row, int col, bool value ) {
3679 SetValueAsLong( row, col, (long)value );
3680 }
3681
3682
3683 PYPRIVATE;
3684 };
3685
3686 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3687
3688 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3689
3690 if (source == Py_None) {
3691 **obj = wxGridCellCoords(-1,-1);
3692 return true;
3693 }
3694
3695 // If source is an object instance then it may already be the right type
3696 if (wxPySwigInstance_Check(source)) {
3697 wxGridCellCoords* ptr;
3698 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3699 goto error;
3700 *obj = ptr;
3701 return true;
3702 }
3703 // otherwise a 2-tuple of integers is expected
3704 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3705 PyObject* o1 = PySequence_GetItem(source, 0);
3706 PyObject* o2 = PySequence_GetItem(source, 1);
3707 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3708 Py_DECREF(o1);
3709 Py_DECREF(o2);
3710 goto error;
3711 }
3712 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3713 Py_DECREF(o1);
3714 Py_DECREF(o2);
3715 return true;
3716 }
3717
3718 error:
3719 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3720 return false;
3721 }
3722
3723
3724 bool wxGridCellCoords_typecheck(PyObject* source) {
3725 void* ptr;
3726
3727 if (wxPySwigInstance_Check(source) &&
3728 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3729 return true;
3730
3731 PyErr_Clear();
3732 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3733 return true;
3734
3735 return false;
3736 }
3737
3738
3739 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3740 {
3741 PyObject* list = PyList_New(0);
3742 size_t idx;
3743 for (idx = 0; idx < source.GetCount(); idx += 1) {
3744 wxGridCellCoords& coord = source.Item(idx);
3745 PyObject* tup = PyTuple_New(2);
3746 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3747 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3748 PyList_Append(list, tup);
3749 Py_DECREF(tup);
3750 }
3751 return list;
3752 }
3753
3754 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3755 wxGridCellCoords temp, *obj = &temp;
3756 if ( other == Py_None ) return false;
3757 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3758 PyErr_Clear();
3759 return false;
3760 }
3761 return self->operator==(*obj);
3762 }
3763 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3764 wxGridCellCoords temp, *obj = &temp;
3765 if ( other == Py_None ) return true;
3766 if ( ! wxGridCellCoords_helper(other, &obj)) {
3767 PyErr_Clear();
3768 return true;
3769 }
3770 return self->operator!=(*obj);
3771 }
3772 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3773 PyObject* tup = PyTuple_New(2);
3774 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3775 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3776 return tup;
3777 }
3778
3779 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3780
3781 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3782 wxGridCellCoords rv;
3783 self->XYToCell(x, y, rv);
3784 return rv;
3785 }
3786 #ifdef __cplusplus
3787 extern "C" {
3788 #endif
3789 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3790 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3791 return 1;
3792 }
3793
3794
3795 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3796 PyObject *pyobj = 0;
3797
3798 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3799 return pyobj;
3800 }
3801
3802
3803 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3804 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3805 return 1;
3806 }
3807
3808
3809 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3810 PyObject *pyobj = 0;
3811
3812 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3813 return pyobj;
3814 }
3815
3816
3817 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj = 0;
3819 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3820 PyObject *arg2 = (PyObject *) 0 ;
3821 void *argp1 = 0 ;
3822 int res1 = 0 ;
3823 PyObject * obj0 = 0 ;
3824 PyObject * obj1 = 0 ;
3825 char * kwnames[] = {
3826 (char *) "self",(char *) "_self", NULL
3827 };
3828
3829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3831 if (!SWIG_IsOK(res1)) {
3832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3833 }
3834 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3835 arg2 = obj1;
3836 {
3837 PyThreadState* __tstate = wxPyBeginAllowThreads();
3838 wxGridCellWorker__setOORInfo(arg1,arg2);
3839 wxPyEndAllowThreads(__tstate);
3840 if (PyErr_Occurred()) SWIG_fail;
3841 }
3842 resultobj = SWIG_Py_Void();
3843 return resultobj;
3844 fail:
3845 return NULL;
3846 }
3847
3848
3849 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3850 PyObject *resultobj = 0;
3851 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3852 void *argp1 = 0 ;
3853 int res1 = 0 ;
3854 PyObject *swig_obj[1] ;
3855
3856 if (!args) SWIG_fail;
3857 swig_obj[0] = args;
3858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3859 if (!SWIG_IsOK(res1)) {
3860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3861 }
3862 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3863 {
3864 PyThreadState* __tstate = wxPyBeginAllowThreads();
3865 delete_wxGridCellWorker(arg1);
3866
3867 wxPyEndAllowThreads(__tstate);
3868 if (PyErr_Occurred()) SWIG_fail;
3869 }
3870 resultobj = SWIG_Py_Void();
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj = 0;
3879 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3880 wxString *arg2 = 0 ;
3881 void *argp1 = 0 ;
3882 int res1 = 0 ;
3883 bool temp2 = false ;
3884 PyObject * obj0 = 0 ;
3885 PyObject * obj1 = 0 ;
3886 char * kwnames[] = {
3887 (char *) "self",(char *) "params", NULL
3888 };
3889
3890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3892 if (!SWIG_IsOK(res1)) {
3893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3894 }
3895 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3896 {
3897 arg2 = wxString_in_helper(obj1);
3898 if (arg2 == NULL) SWIG_fail;
3899 temp2 = true;
3900 }
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 (arg1)->SetParameters((wxString const &)*arg2);
3904 wxPyEndAllowThreads(__tstate);
3905 if (PyErr_Occurred()) SWIG_fail;
3906 }
3907 resultobj = SWIG_Py_Void();
3908 {
3909 if (temp2)
3910 delete arg2;
3911 }
3912 return resultobj;
3913 fail:
3914 {
3915 if (temp2)
3916 delete arg2;
3917 }
3918 return NULL;
3919 }
3920
3921
3922 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3923 PyObject *resultobj = 0;
3924 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3925 void *argp1 = 0 ;
3926 int res1 = 0 ;
3927 PyObject *swig_obj[1] ;
3928
3929 if (!args) SWIG_fail;
3930 swig_obj[0] = args;
3931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3932 if (!SWIG_IsOK(res1)) {
3933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3934 }
3935 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 (arg1)->IncRef();
3939 wxPyEndAllowThreads(__tstate);
3940 if (PyErr_Occurred()) SWIG_fail;
3941 }
3942 resultobj = SWIG_Py_Void();
3943 return resultobj;
3944 fail:
3945 return NULL;
3946 }
3947
3948
3949 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3950 PyObject *resultobj = 0;
3951 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3952 void *argp1 = 0 ;
3953 int res1 = 0 ;
3954 PyObject *swig_obj[1] ;
3955
3956 if (!args) SWIG_fail;
3957 swig_obj[0] = args;
3958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3959 if (!SWIG_IsOK(res1)) {
3960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3961 }
3962 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3963 {
3964 PyThreadState* __tstate = wxPyBeginAllowThreads();
3965 (arg1)->DecRef();
3966 wxPyEndAllowThreads(__tstate);
3967 if (PyErr_Occurred()) SWIG_fail;
3968 }
3969 resultobj = SWIG_Py_Void();
3970 return resultobj;
3971 fail:
3972 return NULL;
3973 }
3974
3975
3976 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3977 PyObject *obj;
3978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3979 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3980 return SWIG_Py_Void();
3981 }
3982
3983 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3984 PyObject *resultobj = 0;
3985 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3986 wxGrid *arg2 = 0 ;
3987 wxGridCellAttr *arg3 = 0 ;
3988 wxDC *arg4 = 0 ;
3989 wxRect *arg5 = 0 ;
3990 int arg6 ;
3991 int arg7 ;
3992 bool arg8 ;
3993 void *argp1 = 0 ;
3994 int res1 = 0 ;
3995 void *argp2 = 0 ;
3996 int res2 = 0 ;
3997 void *argp3 = 0 ;
3998 int res3 = 0 ;
3999 void *argp4 = 0 ;
4000 int res4 = 0 ;
4001 wxRect temp5 ;
4002 int val6 ;
4003 int ecode6 = 0 ;
4004 int val7 ;
4005 int ecode7 = 0 ;
4006 bool val8 ;
4007 int ecode8 = 0 ;
4008 PyObject * obj0 = 0 ;
4009 PyObject * obj1 = 0 ;
4010 PyObject * obj2 = 0 ;
4011 PyObject * obj3 = 0 ;
4012 PyObject * obj4 = 0 ;
4013 PyObject * obj5 = 0 ;
4014 PyObject * obj6 = 0 ;
4015 PyObject * obj7 = 0 ;
4016 char * kwnames[] = {
4017 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4018 };
4019
4020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4022 if (!SWIG_IsOK(res1)) {
4023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4024 }
4025 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4026 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4027 if (!SWIG_IsOK(res2)) {
4028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4029 }
4030 if (!argp2) {
4031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4032 }
4033 arg2 = reinterpret_cast< wxGrid * >(argp2);
4034 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4035 if (!SWIG_IsOK(res3)) {
4036 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4037 }
4038 if (!argp3) {
4039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4040 }
4041 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4042 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4043 if (!SWIG_IsOK(res4)) {
4044 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4045 }
4046 if (!argp4) {
4047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4048 }
4049 arg4 = reinterpret_cast< wxDC * >(argp4);
4050 {
4051 arg5 = &temp5;
4052 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4053 }
4054 ecode6 = SWIG_AsVal_int(obj5, &val6);
4055 if (!SWIG_IsOK(ecode6)) {
4056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4057 }
4058 arg6 = static_cast< int >(val6);
4059 ecode7 = SWIG_AsVal_int(obj6, &val7);
4060 if (!SWIG_IsOK(ecode7)) {
4061 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4062 }
4063 arg7 = static_cast< int >(val7);
4064 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4065 if (!SWIG_IsOK(ecode8)) {
4066 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4067 }
4068 arg8 = static_cast< bool >(val8);
4069 {
4070 PyThreadState* __tstate = wxPyBeginAllowThreads();
4071 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4072 wxPyEndAllowThreads(__tstate);
4073 if (PyErr_Occurred()) SWIG_fail;
4074 }
4075 resultobj = SWIG_Py_Void();
4076 return resultobj;
4077 fail:
4078 return NULL;
4079 }
4080
4081
4082 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4083 PyObject *resultobj = 0;
4084 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4085 wxGrid *arg2 = 0 ;
4086 wxGridCellAttr *arg3 = 0 ;
4087 wxDC *arg4 = 0 ;
4088 int arg5 ;
4089 int arg6 ;
4090 wxSize result;
4091 void *argp1 = 0 ;
4092 int res1 = 0 ;
4093 void *argp2 = 0 ;
4094 int res2 = 0 ;
4095 void *argp3 = 0 ;
4096 int res3 = 0 ;
4097 void *argp4 = 0 ;
4098 int res4 = 0 ;
4099 int val5 ;
4100 int ecode5 = 0 ;
4101 int val6 ;
4102 int ecode6 = 0 ;
4103 PyObject * obj0 = 0 ;
4104 PyObject * obj1 = 0 ;
4105 PyObject * obj2 = 0 ;
4106 PyObject * obj3 = 0 ;
4107 PyObject * obj4 = 0 ;
4108 PyObject * obj5 = 0 ;
4109 char * kwnames[] = {
4110 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4111 };
4112
4113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4115 if (!SWIG_IsOK(res1)) {
4116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4117 }
4118 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4120 if (!SWIG_IsOK(res2)) {
4121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4122 }
4123 if (!argp2) {
4124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4125 }
4126 arg2 = reinterpret_cast< wxGrid * >(argp2);
4127 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4128 if (!SWIG_IsOK(res3)) {
4129 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4130 }
4131 if (!argp3) {
4132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4133 }
4134 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4135 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4136 if (!SWIG_IsOK(res4)) {
4137 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4138 }
4139 if (!argp4) {
4140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4141 }
4142 arg4 = reinterpret_cast< wxDC * >(argp4);
4143 ecode5 = SWIG_AsVal_int(obj4, &val5);
4144 if (!SWIG_IsOK(ecode5)) {
4145 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4146 }
4147 arg5 = static_cast< int >(val5);
4148 ecode6 = SWIG_AsVal_int(obj5, &val6);
4149 if (!SWIG_IsOK(ecode6)) {
4150 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4151 }
4152 arg6 = static_cast< int >(val6);
4153 {
4154 PyThreadState* __tstate = wxPyBeginAllowThreads();
4155 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4156 wxPyEndAllowThreads(__tstate);
4157 if (PyErr_Occurred()) SWIG_fail;
4158 }
4159 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4167 PyObject *resultobj = 0;
4168 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4169 wxGridCellRenderer *result = 0 ;
4170 void *argp1 = 0 ;
4171 int res1 = 0 ;
4172 PyObject *swig_obj[1] ;
4173
4174 if (!args) SWIG_fail;
4175 swig_obj[0] = args;
4176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4177 if (!SWIG_IsOK(res1)) {
4178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4179 }
4180 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4181 {
4182 PyThreadState* __tstate = wxPyBeginAllowThreads();
4183 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 {
4188 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4189 }
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4197 PyObject *obj;
4198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4199 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4200 return SWIG_Py_Void();
4201 }
4202
4203 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4204 PyObject *resultobj = 0;
4205 wxPyGridCellRenderer *result = 0 ;
4206
4207 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj = 0;
4223 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4224 PyObject *arg2 = (PyObject *) 0 ;
4225 PyObject *arg3 = (PyObject *) 0 ;
4226 void *argp1 = 0 ;
4227 int res1 = 0 ;
4228 PyObject * obj0 = 0 ;
4229 PyObject * obj1 = 0 ;
4230 PyObject * obj2 = 0 ;
4231 char * kwnames[] = {
4232 (char *) "self",(char *) "self",(char *) "_class", NULL
4233 };
4234
4235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4237 if (!SWIG_IsOK(res1)) {
4238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4239 }
4240 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4241 arg2 = obj1;
4242 arg3 = obj2;
4243 {
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 (arg1)->_setCallbackInfo(arg2,arg3);
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_Py_Void();
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = 0;
4258 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4259 wxString *arg2 = 0 ;
4260 void *argp1 = 0 ;
4261 int res1 = 0 ;
4262 bool temp2 = false ;
4263 PyObject * obj0 = 0 ;
4264 PyObject * obj1 = 0 ;
4265 char * kwnames[] = {
4266 (char *) "self",(char *) "params", NULL
4267 };
4268
4269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4271 if (!SWIG_IsOK(res1)) {
4272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4273 }
4274 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4275 {
4276 arg2 = wxString_in_helper(obj1);
4277 if (arg2 == NULL) SWIG_fail;
4278 temp2 = true;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 (arg1)->SetParameters((wxString const &)*arg2);
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_Py_Void();
4287 {
4288 if (temp2)
4289 delete arg2;
4290 }
4291 return resultobj;
4292 fail:
4293 {
4294 if (temp2)
4295 delete arg2;
4296 }
4297 return NULL;
4298 }
4299
4300
4301 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4302 PyObject *obj;
4303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4304 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4305 return SWIG_Py_Void();
4306 }
4307
4308 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 return SWIG_Python_InitShadowInstance(args);
4310 }
4311
4312 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4313 PyObject *resultobj = 0;
4314 wxGridCellStringRenderer *result = 0 ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 PyObject *obj;
4332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4333 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4334 return SWIG_Py_Void();
4335 }
4336
4337 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4338 return SWIG_Python_InitShadowInstance(args);
4339 }
4340
4341 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4342 PyObject *resultobj = 0;
4343 wxGridCellNumberRenderer *result = 0 ;
4344
4345 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4360 PyObject *obj;
4361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4362 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4363 return SWIG_Py_Void();
4364 }
4365
4366 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4367 return SWIG_Python_InitShadowInstance(args);
4368 }
4369
4370 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = 0;
4372 int arg1 = (int) -1 ;
4373 int arg2 = (int) -1 ;
4374 wxGridCellFloatRenderer *result = 0 ;
4375 int val1 ;
4376 int ecode1 = 0 ;
4377 int val2 ;
4378 int ecode2 = 0 ;
4379 PyObject * obj0 = 0 ;
4380 PyObject * obj1 = 0 ;
4381 char * kwnames[] = {
4382 (char *) "width",(char *) "precision", NULL
4383 };
4384
4385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4386 if (obj0) {
4387 ecode1 = SWIG_AsVal_int(obj0, &val1);
4388 if (!SWIG_IsOK(ecode1)) {
4389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4390 }
4391 arg1 = static_cast< int >(val1);
4392 }
4393 if (obj1) {
4394 ecode2 = SWIG_AsVal_int(obj1, &val2);
4395 if (!SWIG_IsOK(ecode2)) {
4396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4397 }
4398 arg2 = static_cast< int >(val2);
4399 }
4400 {
4401 PyThreadState* __tstate = wxPyBeginAllowThreads();
4402 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4403 wxPyEndAllowThreads(__tstate);
4404 if (PyErr_Occurred()) SWIG_fail;
4405 }
4406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4416 int result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4426 }
4427 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 resultobj = SWIG_From_int(static_cast< int >(result));
4435 return resultobj;
4436 fail:
4437 return NULL;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4442 PyObject *resultobj = 0;
4443 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4444 int arg2 ;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 int val2 ;
4448 int ecode2 = 0 ;
4449 PyObject * obj0 = 0 ;
4450 PyObject * obj1 = 0 ;
4451 char * kwnames[] = {
4452 (char *) "self",(char *) "width", NULL
4453 };
4454
4455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4459 }
4460 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4461 ecode2 = SWIG_AsVal_int(obj1, &val2);
4462 if (!SWIG_IsOK(ecode2)) {
4463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4464 }
4465 arg2 = static_cast< int >(val2);
4466 {
4467 PyThreadState* __tstate = wxPyBeginAllowThreads();
4468 (arg1)->SetWidth(arg2);
4469 wxPyEndAllowThreads(__tstate);
4470 if (PyErr_Occurred()) SWIG_fail;
4471 }
4472 resultobj = SWIG_Py_Void();
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4480 PyObject *resultobj = 0;
4481 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4482 int result;
4483 void *argp1 = 0 ;
4484 int res1 = 0 ;
4485 PyObject *swig_obj[1] ;
4486
4487 if (!args) SWIG_fail;
4488 swig_obj[0] = args;
4489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4490 if (!SWIG_IsOK(res1)) {
4491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4492 }
4493 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 resultobj = SWIG_From_int(static_cast< int >(result));
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4510 int arg2 ;
4511 void *argp1 = 0 ;
4512 int res1 = 0 ;
4513 int val2 ;
4514 int ecode2 = 0 ;
4515 PyObject * obj0 = 0 ;
4516 PyObject * obj1 = 0 ;
4517 char * kwnames[] = {
4518 (char *) "self",(char *) "precision", NULL
4519 };
4520
4521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4525 }
4526 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4527 ecode2 = SWIG_AsVal_int(obj1, &val2);
4528 if (!SWIG_IsOK(ecode2)) {
4529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4530 }
4531 arg2 = static_cast< int >(val2);
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 (arg1)->SetPrecision(arg2);
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 resultobj = SWIG_Py_Void();
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546 PyObject *obj;
4547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4548 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4549 return SWIG_Py_Void();
4550 }
4551
4552 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4553 return SWIG_Python_InitShadowInstance(args);
4554 }
4555
4556 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4557 PyObject *resultobj = 0;
4558 wxGridCellBoolRenderer *result = 0 ;
4559
4560 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4568 return resultobj;
4569 fail:
4570 return NULL;
4571 }
4572
4573
4574 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4575 PyObject *obj;
4576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4577 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4578 return SWIG_Py_Void();
4579 }
4580
4581 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 return SWIG_Python_InitShadowInstance(args);
4583 }
4584
4585 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4586 PyObject *resultobj = 0;
4587 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4588 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4589 wxGridCellDateTimeRenderer *result = 0 ;
4590 PyObject * obj0 = 0 ;
4591 PyObject * obj1 = 0 ;
4592 char * kwnames[] = {
4593 (char *) "outformat",(char *) "informat", NULL
4594 };
4595
4596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4597 if (obj0) {
4598 {
4599 wxString* sptr = wxString_in_helper(obj0);
4600 if (sptr == NULL) SWIG_fail;
4601 arg1 = *sptr;
4602 delete sptr;
4603 }
4604 }
4605 if (obj1) {
4606 {
4607 wxString* sptr = wxString_in_helper(obj1);
4608 if (sptr == NULL) SWIG_fail;
4609 arg2 = *sptr;
4610 delete sptr;
4611 }
4612 }
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4627 PyObject *obj;
4628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4629 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4630 return SWIG_Py_Void();
4631 }
4632
4633 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4634 return SWIG_Python_InitShadowInstance(args);
4635 }
4636
4637 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj = 0;
4639 wxString const &arg1_defvalue = wxPyEmptyString ;
4640 wxString *arg1 = (wxString *) &arg1_defvalue ;
4641 wxGridCellEnumRenderer *result = 0 ;
4642 bool temp1 = false ;
4643 PyObject * obj0 = 0 ;
4644 char * kwnames[] = {
4645 (char *) "choices", NULL
4646 };
4647
4648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4649 if (obj0) {
4650 {
4651 arg1 = wxString_in_helper(obj0);
4652 if (arg1 == NULL) SWIG_fail;
4653 temp1 = true;
4654 }
4655 }
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4663 {
4664 if (temp1)
4665 delete arg1;
4666 }
4667 return resultobj;
4668 fail:
4669 {
4670 if (temp1)
4671 delete arg1;
4672 }
4673 return NULL;
4674 }
4675
4676
4677 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4678 PyObject *obj;
4679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4680 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4681 return SWIG_Py_Void();
4682 }
4683
4684 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4685 return SWIG_Python_InitShadowInstance(args);
4686 }
4687
4688 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4689 PyObject *resultobj = 0;
4690 wxGridCellAutoWrapStringRenderer *result = 0 ;
4691
4692 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4693 {
4694 PyThreadState* __tstate = wxPyBeginAllowThreads();
4695 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4707 PyObject *obj;
4708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4709 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4710 return SWIG_Py_Void();
4711 }
4712
4713 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4714 return SWIG_Python_InitShadowInstance(args);
4715 }
4716
4717 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4718 PyObject *resultobj = 0;
4719 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4720 bool result;
4721 void *argp1 = 0 ;
4722 int res1 = 0 ;
4723 PyObject *swig_obj[1] ;
4724
4725 if (!args) SWIG_fail;
4726 swig_obj[0] = args;
4727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4728 if (!SWIG_IsOK(res1)) {
4729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4730 }
4731 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (bool)(arg1)->IsCreated();
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4740 }
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4748 PyObject *resultobj = 0;
4749 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4750 wxControl *result = 0 ;
4751 void *argp1 = 0 ;
4752 int res1 = 0 ;
4753 PyObject *swig_obj[1] ;
4754
4755 if (!args) SWIG_fail;
4756 swig_obj[0] = args;
4757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4758 if (!SWIG_IsOK(res1)) {
4759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4760 }
4761 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4762 {
4763 PyThreadState* __tstate = wxPyBeginAllowThreads();
4764 result = (wxControl *)(arg1)->GetControl();
4765 wxPyEndAllowThreads(__tstate);
4766 if (PyErr_Occurred()) SWIG_fail;
4767 }
4768 {
4769 resultobj = wxPyMake_wxObject(result, 0);
4770 }
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj = 0;
4779 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4780 wxControl *arg2 = (wxControl *) 0 ;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 void *argp2 = 0 ;
4784 int res2 = 0 ;
4785 PyObject * obj0 = 0 ;
4786 PyObject * obj1 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "control", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4795 }
4796 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4797 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4798 if (!SWIG_IsOK(res2)) {
4799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4800 }
4801 arg2 = reinterpret_cast< wxControl * >(argp2);
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 (arg1)->SetControl(arg2);
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4816 PyObject *resultobj = 0;
4817 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4818 wxGridCellAttr *result = 0 ;
4819 void *argp1 = 0 ;
4820 int res1 = 0 ;
4821 PyObject *swig_obj[1] ;
4822
4823 if (!args) SWIG_fail;
4824 swig_obj[0] = args;
4825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4826 if (!SWIG_IsOK(res1)) {
4827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4828 }
4829 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 {
4837 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4838 }
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj = 0;
4847 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4848 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 void *argp2 = 0 ;
4852 int res2 = 0 ;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 char * kwnames[] = {
4856 (char *) "self",(char *) "attr", NULL
4857 };
4858
4859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4861 if (!SWIG_IsOK(res1)) {
4862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4863 }
4864 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4866 if (!SWIG_IsOK(res2)) {
4867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4868 }
4869 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 (arg1)->SetCellAttr(arg2);
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_Py_Void();
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj = 0;
4885 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4886 wxWindow *arg2 = (wxWindow *) 0 ;
4887 int arg3 ;
4888 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4889 void *argp1 = 0 ;
4890 int res1 = 0 ;
4891 void *argp2 = 0 ;
4892 int res2 = 0 ;
4893 int val3 ;
4894 int ecode3 = 0 ;
4895 void *argp4 = 0 ;
4896 int res4 = 0 ;
4897 PyObject * obj0 = 0 ;
4898 PyObject * obj1 = 0 ;
4899 PyObject * obj2 = 0 ;
4900 PyObject * obj3 = 0 ;
4901 char * kwnames[] = {
4902 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4903 };
4904
4905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4907 if (!SWIG_IsOK(res1)) {
4908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4909 }
4910 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4912 if (!SWIG_IsOK(res2)) {
4913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4914 }
4915 arg2 = reinterpret_cast< wxWindow * >(argp2);
4916 ecode3 = SWIG_AsVal_int(obj2, &val3);
4917 if (!SWIG_IsOK(ecode3)) {
4918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4919 }
4920 arg3 = static_cast< int >(val3);
4921 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4922 if (!SWIG_IsOK(res4)) {
4923 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4924 }
4925 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4926 {
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 (arg1)->Create(arg2,arg3,arg4);
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_Py_Void();
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4942 int arg2 ;
4943 int arg3 ;
4944 wxGrid *arg4 = (wxGrid *) 0 ;
4945 void *argp1 = 0 ;
4946 int res1 = 0 ;
4947 int val2 ;
4948 int ecode2 = 0 ;
4949 int val3 ;
4950 int ecode3 = 0 ;
4951 void *argp4 = 0 ;
4952 int res4 = 0 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 PyObject * obj2 = 0 ;
4956 PyObject * obj3 = 0 ;
4957 char * kwnames[] = {
4958 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4959 };
4960
4961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4963 if (!SWIG_IsOK(res1)) {
4964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4965 }
4966 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4967 ecode2 = SWIG_AsVal_int(obj1, &val2);
4968 if (!SWIG_IsOK(ecode2)) {
4969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4970 }
4971 arg2 = static_cast< int >(val2);
4972 ecode3 = SWIG_AsVal_int(obj2, &val3);
4973 if (!SWIG_IsOK(ecode3)) {
4974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4975 }
4976 arg3 = static_cast< int >(val3);
4977 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4978 if (!SWIG_IsOK(res4)) {
4979 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4980 }
4981 arg4 = reinterpret_cast< wxGrid * >(argp4);
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 (arg1)->BeginEdit(arg2,arg3,arg4);
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = SWIG_Py_Void();
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj = 0;
4997 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4998 int arg2 ;
4999 int arg3 ;
5000 wxGrid *arg4 = (wxGrid *) 0 ;
5001 bool result;
5002 void *argp1 = 0 ;
5003 int res1 = 0 ;
5004 int val2 ;
5005 int ecode2 = 0 ;
5006 int val3 ;
5007 int ecode3 = 0 ;
5008 void *argp4 = 0 ;
5009 int res4 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 PyObject * obj2 = 0 ;
5013 PyObject * obj3 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5022 }
5023 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5024 ecode2 = SWIG_AsVal_int(obj1, &val2);
5025 if (!SWIG_IsOK(ecode2)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5027 }
5028 arg2 = static_cast< int >(val2);
5029 ecode3 = SWIG_AsVal_int(obj2, &val3);
5030 if (!SWIG_IsOK(ecode3)) {
5031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5032 }
5033 arg3 = static_cast< int >(val3);
5034 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5035 if (!SWIG_IsOK(res4)) {
5036 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5037 }
5038 arg4 = reinterpret_cast< wxGrid * >(argp4);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5057 void *argp1 = 0 ;
5058 int res1 = 0 ;
5059 PyObject *swig_obj[1] ;
5060
5061 if (!args) SWIG_fail;
5062 swig_obj[0] = args;
5063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5066 }
5067 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->Reset();
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5084 wxGridCellEditor *result = 0 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 PyObject *swig_obj[1] ;
5088
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5094 }
5095 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5114 wxRect *arg2 = 0 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 wxRect temp2 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "rect", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5128 }
5129 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5130 {
5131 arg2 = &temp2;
5132 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5133 }
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 (arg1)->SetSize((wxRect const &)*arg2);
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 resultobj = SWIG_Py_Void();
5141 return resultobj;
5142 fail:
5143 return NULL;
5144 }
5145
5146
5147 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5148 PyObject *resultobj = 0;
5149 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5150 bool arg2 ;
5151 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 bool val2 ;
5155 int ecode2 = 0 ;
5156 void *argp3 = 0 ;
5157 int res3 = 0 ;
5158 PyObject * obj0 = 0 ;
5159 PyObject * obj1 = 0 ;
5160 PyObject * obj2 = 0 ;
5161 char * kwnames[] = {
5162 (char *) "self",(char *) "show",(char *) "attr", NULL
5163 };
5164
5165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5167 if (!SWIG_IsOK(res1)) {
5168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5169 }
5170 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5172 if (!SWIG_IsOK(ecode2)) {
5173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5174 }
5175 arg2 = static_cast< bool >(val2);
5176 if (obj2) {
5177 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5178 if (!SWIG_IsOK(res3)) {
5179 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5180 }
5181 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5182 }
5183 {
5184 PyThreadState* __tstate = wxPyBeginAllowThreads();
5185 (arg1)->Show(arg2,arg3);
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 resultobj = SWIG_Py_Void();
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj = 0;
5198 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5199 wxRect *arg2 = 0 ;
5200 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 wxRect temp2 ;
5204 void *argp3 = 0 ;
5205 int res3 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 PyObject * obj1 = 0 ;
5208 PyObject * obj2 = 0 ;
5209 char * kwnames[] = {
5210 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5211 };
5212
5213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5215 if (!SWIG_IsOK(res1)) {
5216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5217 }
5218 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5219 {
5220 arg2 = &temp2;
5221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5222 }
5223 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5224 if (!SWIG_IsOK(res3)) {
5225 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5226 }
5227 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 resultobj = SWIG_Py_Void();
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj = 0;
5243 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5244 wxKeyEvent *arg2 = 0 ;
5245 bool result;
5246 void *argp1 = 0 ;
5247 int res1 = 0 ;
5248 void *argp2 = 0 ;
5249 int res2 = 0 ;
5250 PyObject * obj0 = 0 ;
5251 PyObject * obj1 = 0 ;
5252 char * kwnames[] = {
5253 (char *) "self",(char *) "event", NULL
5254 };
5255
5256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5258 if (!SWIG_IsOK(res1)) {
5259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5260 }
5261 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5263 if (!SWIG_IsOK(res2)) {
5264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5265 }
5266 if (!argp2) {
5267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5268 }
5269 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 {
5277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5278 }
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5286 PyObject *resultobj = 0;
5287 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5288 wxKeyEvent *arg2 = 0 ;
5289 void *argp1 = 0 ;
5290 int res1 = 0 ;
5291 void *argp2 = 0 ;
5292 int res2 = 0 ;
5293 PyObject * obj0 = 0 ;
5294 PyObject * obj1 = 0 ;
5295 char * kwnames[] = {
5296 (char *) "self",(char *) "event", NULL
5297 };
5298
5299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5301 if (!SWIG_IsOK(res1)) {
5302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5303 }
5304 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5306 if (!SWIG_IsOK(res2)) {
5307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5308 }
5309 if (!argp2) {
5310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5311 }
5312 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5313 {
5314 PyThreadState* __tstate = wxPyBeginAllowThreads();
5315 (arg1)->StartingKey(*arg2);
5316 wxPyEndAllowThreads(__tstate);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 resultobj = SWIG_Py_Void();
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5327 PyObject *resultobj = 0;
5328 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5329 void *argp1 = 0 ;
5330 int res1 = 0 ;
5331 PyObject *swig_obj[1] ;
5332
5333 if (!args) SWIG_fail;
5334 swig_obj[0] = args;
5335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5336 if (!SWIG_IsOK(res1)) {
5337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5338 }
5339 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 (arg1)->StartingClick();
5343 wxPyEndAllowThreads(__tstate);
5344 if (PyErr_Occurred()) SWIG_fail;
5345 }
5346 resultobj = SWIG_Py_Void();
5347 return resultobj;
5348 fail:
5349 return NULL;
5350 }
5351
5352
5353 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5354 PyObject *resultobj = 0;
5355 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5356 wxKeyEvent *arg2 = 0 ;
5357 void *argp1 = 0 ;
5358 int res1 = 0 ;
5359 void *argp2 = 0 ;
5360 int res2 = 0 ;
5361 PyObject * obj0 = 0 ;
5362 PyObject * obj1 = 0 ;
5363 char * kwnames[] = {
5364 (char *) "self",(char *) "event", NULL
5365 };
5366
5367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5369 if (!SWIG_IsOK(res1)) {
5370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5371 }
5372 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5373 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5374 if (!SWIG_IsOK(res2)) {
5375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5376 }
5377 if (!argp2) {
5378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5379 }
5380 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 (arg1)->HandleReturn(*arg2);
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 resultobj = SWIG_Py_Void();
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5395 PyObject *resultobj = 0;
5396 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5397 void *argp1 = 0 ;
5398 int res1 = 0 ;
5399 PyObject *swig_obj[1] ;
5400
5401 if (!args) SWIG_fail;
5402 swig_obj[0] = args;
5403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5404 if (!SWIG_IsOK(res1)) {
5405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5406 }
5407 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5408 {
5409 PyThreadState* __tstate = wxPyBeginAllowThreads();
5410 (arg1)->Destroy();
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 resultobj = SWIG_Py_Void();
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *obj;
5423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5424 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5425 return SWIG_Py_Void();
5426 }
5427
5428 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxPyGridCellEditor *result = 0 ;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5449 PyObject *arg2 = (PyObject *) 0 ;
5450 PyObject *arg3 = (PyObject *) 0 ;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 PyObject * obj0 = 0 ;
5454 PyObject * obj1 = 0 ;
5455 PyObject * obj2 = 0 ;
5456 char * kwnames[] = {
5457 (char *) "self",(char *) "self",(char *) "_class", NULL
5458 };
5459
5460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5464 }
5465 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5466 arg2 = obj1;
5467 arg3 = obj2;
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 (arg1)->_setCallbackInfo(arg2,arg3);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_Py_Void();
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5484 wxString *arg2 = 0 ;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 bool temp2 = false ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 char * kwnames[] = {
5491 (char *) "self",(char *) "params", NULL
5492 };
5493
5494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5496 if (!SWIG_IsOK(res1)) {
5497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5498 }
5499 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5500 {
5501 arg2 = wxString_in_helper(obj1);
5502 if (arg2 == NULL) SWIG_fail;
5503 temp2 = true;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 (arg1)->SetParameters((wxString const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_Py_Void();
5512 {
5513 if (temp2)
5514 delete arg2;
5515 }
5516 return resultobj;
5517 fail:
5518 {
5519 if (temp2)
5520 delete arg2;
5521 }
5522 return NULL;
5523 }
5524
5525
5526 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5527 PyObject *obj;
5528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5529 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5530 return SWIG_Py_Void();
5531 }
5532
5533 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 return SWIG_Python_InitShadowInstance(args);
5535 }
5536
5537 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5538 PyObject *resultobj = 0;
5539 wxGridCellTextEditor *result = 0 ;
5540
5541 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5542 {
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5558 wxString result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject *swig_obj[1] ;
5562
5563 if (!args) SWIG_fail;
5564 swig_obj[0] = args;
5565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5568 }
5569 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5570 {
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 result = (arg1)->GetValue();
5573 wxPyEndAllowThreads(__tstate);
5574 if (PyErr_Occurred()) SWIG_fail;
5575 }
5576 {
5577 #if wxUSE_UNICODE
5578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5579 #else
5580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5581 #endif
5582 }
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5590 PyObject *obj;
5591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5592 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5593 return SWIG_Py_Void();
5594 }
5595
5596 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5597 return SWIG_Python_InitShadowInstance(args);
5598 }
5599
5600 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj = 0;
5602 int arg1 = (int) -1 ;
5603 int arg2 = (int) -1 ;
5604 wxGridCellNumberEditor *result = 0 ;
5605 int val1 ;
5606 int ecode1 = 0 ;
5607 int val2 ;
5608 int ecode2 = 0 ;
5609 PyObject * obj0 = 0 ;
5610 PyObject * obj1 = 0 ;
5611 char * kwnames[] = {
5612 (char *) "min",(char *) "max", NULL
5613 };
5614
5615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5616 if (obj0) {
5617 ecode1 = SWIG_AsVal_int(obj0, &val1);
5618 if (!SWIG_IsOK(ecode1)) {
5619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5620 }
5621 arg1 = static_cast< int >(val1);
5622 }
5623 if (obj1) {
5624 ecode2 = SWIG_AsVal_int(obj1, &val2);
5625 if (!SWIG_IsOK(ecode2)) {
5626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5627 }
5628 arg2 = static_cast< int >(val2);
5629 }
5630 {
5631 PyThreadState* __tstate = wxPyBeginAllowThreads();
5632 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5633 wxPyEndAllowThreads(__tstate);
5634 if (PyErr_Occurred()) SWIG_fail;
5635 }
5636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5637 return resultobj;
5638 fail:
5639 return NULL;
5640 }
5641
5642
5643 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5644 PyObject *obj;
5645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5646 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5647 return SWIG_Py_Void();
5648 }
5649
5650 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5651 return SWIG_Python_InitShadowInstance(args);
5652 }
5653
5654 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5655 PyObject *resultobj = 0;
5656 int arg1 = (int) -1 ;
5657 int arg2 = (int) -1 ;
5658 wxGridCellFloatEditor *result = 0 ;
5659 int val1 ;
5660 int ecode1 = 0 ;
5661 int val2 ;
5662 int ecode2 = 0 ;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 char * kwnames[] = {
5666 (char *) "width",(char *) "precision", NULL
5667 };
5668
5669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5670 if (obj0) {
5671 ecode1 = SWIG_AsVal_int(obj0, &val1);
5672 if (!SWIG_IsOK(ecode1)) {
5673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5674 }
5675 arg1 = static_cast< int >(val1);
5676 }
5677 if (obj1) {
5678 ecode2 = SWIG_AsVal_int(obj1, &val2);
5679 if (!SWIG_IsOK(ecode2)) {
5680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5681 }
5682 arg2 = static_cast< int >(val2);
5683 }
5684 {
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5687 wxPyEndAllowThreads(__tstate);
5688 if (PyErr_Occurred()) SWIG_fail;
5689 }
5690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5691 return resultobj;
5692 fail:
5693 return NULL;
5694 }
5695
5696
5697 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5698 PyObject *obj;
5699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5700 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5701 return SWIG_Py_Void();
5702 }
5703
5704 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5705 return SWIG_Python_InitShadowInstance(args);
5706 }
5707
5708 SWIGINTERN int OneString_set(PyObject *) {
5709 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5710 return 1;
5711 }
5712
5713
5714 SWIGINTERN PyObject *OneString_get(void) {
5715 PyObject *pyobj = 0;
5716
5717 {
5718 #if wxUSE_UNICODE
5719 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5720 #else
5721 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5722 #endif
5723 }
5724 return pyobj;
5725 }
5726
5727
5728 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 PyObject *resultobj = 0;
5730 wxGridCellBoolEditor *result = 0 ;
5731
5732 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5736 wxPyEndAllowThreads(__tstate);
5737 if (PyErr_Occurred()) SWIG_fail;
5738 }
5739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxString const &arg1_defvalue = wxPyOneString ;
5749 wxString *arg1 = (wxString *) &arg1_defvalue ;
5750 wxString const &arg2_defvalue = wxPyEmptyString ;
5751 wxString *arg2 = (wxString *) &arg2_defvalue ;
5752 bool temp1 = false ;
5753 bool temp2 = false ;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 char * kwnames[] = {
5757 (char *) "valueTrue",(char *) "valueFalse", NULL
5758 };
5759
5760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5761 if (obj0) {
5762 {
5763 arg1 = wxString_in_helper(obj0);
5764 if (arg1 == NULL) SWIG_fail;
5765 temp1 = true;
5766 }
5767 }
5768 if (obj1) {
5769 {
5770 arg2 = wxString_in_helper(obj1);
5771 if (arg2 == NULL) SWIG_fail;
5772 temp2 = true;
5773 }
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 resultobj = SWIG_Py_Void();
5782 {
5783 if (temp1)
5784 delete arg1;
5785 }
5786 {
5787 if (temp2)
5788 delete arg2;
5789 }
5790 return resultobj;
5791 fail:
5792 {
5793 if (temp1)
5794 delete arg1;
5795 }
5796 {
5797 if (temp2)
5798 delete arg2;
5799 }
5800 return NULL;
5801 }
5802
5803
5804 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj = 0;
5806 wxString *arg1 = 0 ;
5807 bool result;
5808 bool temp1 = false ;
5809 PyObject * obj0 = 0 ;
5810 char * kwnames[] = {
5811 (char *) "value", NULL
5812 };
5813
5814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5815 {
5816 arg1 = wxString_in_helper(obj0);
5817 if (arg1 == NULL) SWIG_fail;
5818 temp1 = true;
5819 }
5820 {
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 {
5827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5828 }
5829 {
5830 if (temp1)
5831 delete arg1;
5832 }
5833 return resultobj;
5834 fail:
5835 {
5836 if (temp1)
5837 delete arg1;
5838 }
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5844 PyObject *obj;
5845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5846 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5847 return SWIG_Py_Void();
5848 }
5849
5850 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5851 return SWIG_Python_InitShadowInstance(args);
5852 }
5853
5854 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj = 0;
5856 int arg1 = (int) 0 ;
5857 wxString *arg2 = (wxString *) NULL ;
5858 bool arg3 = (bool) false ;
5859 wxGridCellChoiceEditor *result = 0 ;
5860 bool val3 ;
5861 int ecode3 = 0 ;
5862 PyObject * obj0 = 0 ;
5863 PyObject * obj1 = 0 ;
5864 char * kwnames[] = {
5865 (char *) "choices",(char *) "allowOthers", NULL
5866 };
5867
5868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5869 if (obj0) {
5870 {
5871 arg1 = PyList_Size(obj0);
5872 arg2 = wxString_LIST_helper(obj0);
5873 if (arg2 == NULL) SWIG_fail;
5874 }
5875 }
5876 if (obj1) {
5877 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5878 if (!SWIG_IsOK(ecode3)) {
5879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5880 }
5881 arg3 = static_cast< bool >(val3);
5882 }
5883 {
5884 PyThreadState* __tstate = wxPyBeginAllowThreads();
5885 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5886 wxPyEndAllowThreads(__tstate);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5890 {
5891 if (arg2) delete [] arg2;
5892 }
5893 return resultobj;
5894 fail:
5895 {
5896 if (arg2) delete [] arg2;
5897 }
5898 return NULL;
5899 }
5900
5901
5902 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5903 PyObject *obj;
5904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5905 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5906 return SWIG_Py_Void();
5907 }
5908
5909 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5910 return SWIG_Python_InitShadowInstance(args);
5911 }
5912
5913 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj = 0;
5915 wxString const &arg1_defvalue = wxPyEmptyString ;
5916 wxString *arg1 = (wxString *) &arg1_defvalue ;
5917 wxGridCellEnumEditor *result = 0 ;
5918 bool temp1 = false ;
5919 PyObject * obj0 = 0 ;
5920 char * kwnames[] = {
5921 (char *) "choices", NULL
5922 };
5923
5924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5925 if (obj0) {
5926 {
5927 arg1 = wxString_in_helper(obj0);
5928 if (arg1 == NULL) SWIG_fail;
5929 temp1 = true;
5930 }
5931 }
5932 {
5933 PyThreadState* __tstate = wxPyBeginAllowThreads();
5934 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5939 {
5940 if (temp1)
5941 delete arg1;
5942 }
5943 return resultobj;
5944 fail:
5945 {
5946 if (temp1)
5947 delete arg1;
5948 }
5949 return NULL;
5950 }
5951
5952
5953 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5954 PyObject *obj;
5955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5956 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5957 return SWIG_Py_Void();
5958 }
5959
5960 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5961 return SWIG_Python_InitShadowInstance(args);
5962 }
5963
5964 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5965 PyObject *resultobj = 0;
5966 wxGridCellAutoWrapStringEditor *result = 0 ;
5967
5968 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5983 PyObject *obj;
5984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5985 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5986 return SWIG_Py_Void();
5987 }
5988
5989 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 return SWIG_Python_InitShadowInstance(args);
5991 }
5992
5993 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5994 PyObject *resultobj = 0;
5995 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5996 PyObject *arg2 = (PyObject *) 0 ;
5997 void *argp1 = 0 ;
5998 int res1 = 0 ;
5999 PyObject * obj0 = 0 ;
6000 PyObject * obj1 = 0 ;
6001 char * kwnames[] = {
6002 (char *) "self",(char *) "_self", NULL
6003 };
6004
6005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6007 if (!SWIG_IsOK(res1)) {
6008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6009 }
6010 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6011 arg2 = obj1;
6012 {
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 wxGridCellAttr__setOORInfo(arg1,arg2);
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 resultobj = SWIG_Py_Void();
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj = 0;
6027 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6028 wxGridCellAttr *result = 0 ;
6029 void *argp1 = 0 ;
6030 int res1 = 0 ;
6031 PyObject * obj0 = 0 ;
6032 char * kwnames[] = {
6033 (char *) "attrDefault", NULL
6034 };
6035
6036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6037 if (obj0) {
6038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6039 if (!SWIG_IsOK(res1)) {
6040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6041 }
6042 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6043 }
6044 {
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 {
6051 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6052 }
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6060 PyObject *resultobj = 0;
6061 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6062 void *argp1 = 0 ;
6063 int res1 = 0 ;
6064 PyObject *swig_obj[1] ;
6065
6066 if (!args) SWIG_fail;
6067 swig_obj[0] = args;
6068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6069 if (!SWIG_IsOK(res1)) {
6070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6071 }
6072 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6073 {
6074 PyThreadState* __tstate = wxPyBeginAllowThreads();
6075 delete_wxGridCellAttr(arg1);
6076
6077 wxPyEndAllowThreads(__tstate);
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_Py_Void();
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6088 PyObject *resultobj = 0;
6089 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6090 wxGridCellAttr *result = 0 ;
6091 void *argp1 = 0 ;
6092 int res1 = 0 ;
6093 PyObject *swig_obj[1] ;
6094
6095 if (!args) SWIG_fail;
6096 swig_obj[0] = args;
6097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6098 if (!SWIG_IsOK(res1)) {
6099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6100 }
6101 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6110 }
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj = 0;
6119 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6120 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6121 void *argp1 = 0 ;
6122 int res1 = 0 ;
6123 void *argp2 = 0 ;
6124 int res2 = 0 ;
6125 PyObject * obj0 = 0 ;
6126 PyObject * obj1 = 0 ;
6127 char * kwnames[] = {
6128 (char *) "self",(char *) "mergefrom", NULL
6129 };
6130
6131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6133 if (!SWIG_IsOK(res1)) {
6134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6135 }
6136 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6138 if (!SWIG_IsOK(res2)) {
6139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6140 }
6141 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6142 {
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 (arg1)->MergeWith(arg2);
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 resultobj = SWIG_Py_Void();
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156 PyObject *resultobj = 0;
6157 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6158 void *argp1 = 0 ;
6159 int res1 = 0 ;
6160 PyObject *swig_obj[1] ;
6161
6162 if (!args) SWIG_fail;
6163 swig_obj[0] = args;
6164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6165 if (!SWIG_IsOK(res1)) {
6166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6167 }
6168 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 (arg1)->IncRef();
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_Py_Void();
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6183 PyObject *resultobj = 0;
6184 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6185 void *argp1 = 0 ;
6186 int res1 = 0 ;
6187 PyObject *swig_obj[1] ;
6188
6189 if (!args) SWIG_fail;
6190 swig_obj[0] = args;
6191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6192 if (!SWIG_IsOK(res1)) {
6193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6194 }
6195 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6196 {
6197 PyThreadState* __tstate = wxPyBeginAllowThreads();
6198 (arg1)->DecRef();
6199 wxPyEndAllowThreads(__tstate);
6200 if (PyErr_Occurred()) SWIG_fail;
6201 }
6202 resultobj = SWIG_Py_Void();
6203 return resultobj;
6204 fail:
6205 return NULL;
6206 }
6207
6208
6209 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6210 PyObject *resultobj = 0;
6211 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6212 wxColour *arg2 = 0 ;
6213 void *argp1 = 0 ;
6214 int res1 = 0 ;
6215 wxColour temp2 ;
6216 PyObject * obj0 = 0 ;
6217 PyObject * obj1 = 0 ;
6218 char * kwnames[] = {
6219 (char *) "self",(char *) "colText", NULL
6220 };
6221
6222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6224 if (!SWIG_IsOK(res1)) {
6225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6226 }
6227 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6228 {
6229 arg2 = &temp2;
6230 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6231 }
6232 {
6233 PyThreadState* __tstate = wxPyBeginAllowThreads();
6234 (arg1)->SetTextColour((wxColour const &)*arg2);
6235 wxPyEndAllowThreads(__tstate);
6236 if (PyErr_Occurred()) SWIG_fail;
6237 }
6238 resultobj = SWIG_Py_Void();
6239 return resultobj;
6240 fail:
6241 return NULL;
6242 }
6243
6244
6245 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6246 PyObject *resultobj = 0;
6247 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6248 wxColour *arg2 = 0 ;
6249 void *argp1 = 0 ;
6250 int res1 = 0 ;
6251 wxColour temp2 ;
6252 PyObject * obj0 = 0 ;
6253 PyObject * obj1 = 0 ;
6254 char * kwnames[] = {
6255 (char *) "self",(char *) "colBack", NULL
6256 };
6257
6258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6262 }
6263 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6264 {
6265 arg2 = &temp2;
6266 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6267 }
6268 {
6269 PyThreadState* __tstate = wxPyBeginAllowThreads();
6270 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6271 wxPyEndAllowThreads(__tstate);
6272 if (PyErr_Occurred()) SWIG_fail;
6273 }
6274 resultobj = SWIG_Py_Void();
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6284 wxFont *arg2 = 0 ;
6285 void *argp1 = 0 ;
6286 int res1 = 0 ;
6287 void *argp2 = 0 ;
6288 int res2 = 0 ;
6289 PyObject * obj0 = 0 ;
6290 PyObject * obj1 = 0 ;
6291 char * kwnames[] = {
6292 (char *) "self",(char *) "font", NULL
6293 };
6294
6295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6297 if (!SWIG_IsOK(res1)) {
6298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6299 }
6300 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6301 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6302 if (!SWIG_IsOK(res2)) {
6303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6304 }
6305 if (!argp2) {
6306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6307 }
6308 arg2 = reinterpret_cast< wxFont * >(argp2);
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 (arg1)->SetFont((wxFont const &)*arg2);
6312 wxPyEndAllowThreads(__tstate);
6313 if (PyErr_Occurred()) SWIG_fail;
6314 }
6315 resultobj = SWIG_Py_Void();
6316 return resultobj;
6317 fail:
6318 return NULL;
6319 }
6320
6321
6322 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj = 0;
6324 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6325 int arg2 ;
6326 int arg3 ;
6327 void *argp1 = 0 ;
6328 int res1 = 0 ;
6329 int val2 ;
6330 int ecode2 = 0 ;
6331 int val3 ;
6332 int ecode3 = 0 ;
6333 PyObject * obj0 = 0 ;
6334 PyObject * obj1 = 0 ;
6335 PyObject * obj2 = 0 ;
6336 char * kwnames[] = {
6337 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6338 };
6339
6340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6342 if (!SWIG_IsOK(res1)) {
6343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6344 }
6345 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6346 ecode2 = SWIG_AsVal_int(obj1, &val2);
6347 if (!SWIG_IsOK(ecode2)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6349 }
6350 arg2 = static_cast< int >(val2);
6351 ecode3 = SWIG_AsVal_int(obj2, &val3);
6352 if (!SWIG_IsOK(ecode3)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6354 }
6355 arg3 = static_cast< int >(val3);
6356 {
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 (arg1)->SetAlignment(arg2,arg3);
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 resultobj = SWIG_Py_Void();
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj = 0;
6371 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6372 int arg2 ;
6373 int arg3 ;
6374 void *argp1 = 0 ;
6375 int res1 = 0 ;
6376 int val2 ;
6377 int ecode2 = 0 ;
6378 int val3 ;
6379 int ecode3 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 PyObject * obj2 = 0 ;
6383 char * kwnames[] = {
6384 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6385 };
6386
6387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6389 if (!SWIG_IsOK(res1)) {
6390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6391 }
6392 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6393 ecode2 = SWIG_AsVal_int(obj1, &val2);
6394 if (!SWIG_IsOK(ecode2)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6396 }
6397 arg2 = static_cast< int >(val2);
6398 ecode3 = SWIG_AsVal_int(obj2, &val3);
6399 if (!SWIG_IsOK(ecode3)) {
6400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6401 }
6402 arg3 = static_cast< int >(val3);
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 (arg1)->SetSize(arg2,arg3);
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 resultobj = SWIG_Py_Void();
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6417 PyObject *resultobj = 0;
6418 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6419 bool arg2 = (bool) true ;
6420 void *argp1 = 0 ;
6421 int res1 = 0 ;
6422 bool val2 ;
6423 int ecode2 = 0 ;
6424 PyObject * obj0 = 0 ;
6425 PyObject * obj1 = 0 ;
6426 char * kwnames[] = {
6427 (char *) "self",(char *) "allow", NULL
6428 };
6429
6430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6432 if (!SWIG_IsOK(res1)) {
6433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6434 }
6435 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6436 if (obj1) {
6437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6438 if (!SWIG_IsOK(ecode2)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6440 }
6441 arg2 = static_cast< bool >(val2);
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 (arg1)->SetOverflow(arg2);
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 resultobj = SWIG_Py_Void();
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj = 0;
6458 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6459 bool arg2 = (bool) true ;
6460 void *argp1 = 0 ;
6461 int res1 = 0 ;
6462 bool val2 ;
6463 int ecode2 = 0 ;
6464 PyObject * obj0 = 0 ;
6465 PyObject * obj1 = 0 ;
6466 char * kwnames[] = {
6467 (char *) "self",(char *) "isReadOnly", NULL
6468 };
6469
6470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6474 }
6475 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6476 if (obj1) {
6477 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6478 if (!SWIG_IsOK(ecode2)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6480 }
6481 arg2 = static_cast< bool >(val2);
6482 }
6483 {
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 (arg1)->SetReadOnly(arg2);
6486 wxPyEndAllowThreads(__tstate);
6487 if (PyErr_Occurred()) SWIG_fail;
6488 }
6489 resultobj = SWIG_Py_Void();
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6497 PyObject *resultobj = 0;
6498 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6499 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6500 void *argp1 = 0 ;
6501 int res1 = 0 ;
6502 void *argp2 = 0 ;
6503 int res2 = 0 ;
6504 PyObject * obj0 = 0 ;
6505 PyObject * obj1 = 0 ;
6506 char * kwnames[] = {
6507 (char *) "self",(char *) "renderer", NULL
6508 };
6509
6510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6512 if (!SWIG_IsOK(res1)) {
6513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6514 }
6515 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6517 if (!SWIG_IsOK(res2)) {
6518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6519 }
6520 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->SetRenderer(arg2);
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_Py_Void();
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6537 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 void *argp2 = 0 ;
6541 int res2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "editor", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6552 }
6553 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6555 if (!SWIG_IsOK(res2)) {
6556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6557 }
6558 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 (arg1)->SetEditor(arg2);
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_Py_Void();
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6573 PyObject *resultobj = 0;
6574 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6575 wxGridCellAttr::wxAttrKind arg2 ;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 int val2 ;
6579 int ecode2 = 0 ;
6580 PyObject * obj0 = 0 ;
6581 PyObject * obj1 = 0 ;
6582 char * kwnames[] = {
6583 (char *) "self",(char *) "kind", NULL
6584 };
6585
6586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6588 if (!SWIG_IsOK(res1)) {
6589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6590 }
6591 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6592 ecode2 = SWIG_AsVal_int(obj1, &val2);
6593 if (!SWIG_IsOK(ecode2)) {
6594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6595 }
6596 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6597 {
6598 PyThreadState* __tstate = wxPyBeginAllowThreads();
6599 (arg1)->SetKind(arg2);
6600 wxPyEndAllowThreads(__tstate);
6601 if (PyErr_Occurred()) SWIG_fail;
6602 }
6603 resultobj = SWIG_Py_Void();
6604 return resultobj;
6605 fail:
6606 return NULL;
6607 }
6608
6609
6610 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6611 PyObject *resultobj = 0;
6612 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6613 bool result;
6614 void *argp1 = 0 ;
6615 int res1 = 0 ;
6616 PyObject *swig_obj[1] ;
6617
6618 if (!args) SWIG_fail;
6619 swig_obj[0] = args;
6620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6621 if (!SWIG_IsOK(res1)) {
6622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6623 }
6624 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 {
6632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6633 }
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641 PyObject *resultobj = 0;
6642 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6643 bool result;
6644 void *argp1 = 0 ;
6645 int res1 = 0 ;
6646 PyObject *swig_obj[1] ;
6647
6648 if (!args) SWIG_fail;
6649 swig_obj[0] = args;
6650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6651 if (!SWIG_IsOK(res1)) {
6652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6653 }
6654 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 {
6662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6663 }
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6703 bool result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 {
6722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6723 }
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6731 PyObject *resultobj = 0;
6732 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6733 bool result;
6734 void *argp1 = 0 ;
6735 int res1 = 0 ;
6736 PyObject *swig_obj[1] ;
6737
6738 if (!args) SWIG_fail;
6739 swig_obj[0] = args;
6740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6741 if (!SWIG_IsOK(res1)) {
6742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6743 }
6744 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6748 wxPyEndAllowThreads(__tstate);
6749 if (PyErr_Occurred()) SWIG_fail;
6750 }
6751 {
6752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6753 }
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6763 bool result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 {
6782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6783 }
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6791 PyObject *resultobj = 0;
6792 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6793 bool result;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 PyObject *swig_obj[1] ;
6797
6798 if (!args) SWIG_fail;
6799 swig_obj[0] = args;
6800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6801 if (!SWIG_IsOK(res1)) {
6802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6803 }
6804 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6821 PyObject *resultobj = 0;
6822 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6823 bool result;
6824 void *argp1 = 0 ;
6825 int res1 = 0 ;
6826 PyObject *swig_obj[1] ;
6827
6828 if (!args) SWIG_fail;
6829 swig_obj[0] = args;
6830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6831 if (!SWIG_IsOK(res1)) {
6832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6833 }
6834 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 {
6842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6843 }
6844 return resultobj;
6845 fail:
6846 return NULL;
6847 }
6848
6849
6850 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6851 PyObject *resultobj = 0;
6852 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6853 wxColour result;
6854 void *argp1 = 0 ;
6855 int res1 = 0 ;
6856 PyObject *swig_obj[1] ;
6857
6858 if (!args) SWIG_fail;
6859 swig_obj[0] = args;
6860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6861 if (!SWIG_IsOK(res1)) {
6862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6863 }
6864 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6879 PyObject *resultobj = 0;
6880 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6881 wxColour result;
6882 void *argp1 = 0 ;
6883 int res1 = 0 ;
6884 PyObject *swig_obj[1] ;
6885
6886 if (!args) SWIG_fail;
6887 swig_obj[0] = args;
6888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6889 if (!SWIG_IsOK(res1)) {
6890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6891 }
6892 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6907 PyObject *resultobj = 0;
6908 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6909 wxFont 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_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6919 }
6920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = ((wxGridCellAttr const *)arg1)->GetFont();
6924 wxPyEndAllowThreads(__tstate);
6925 if (PyErr_Occurred()) SWIG_fail;
6926 }
6927 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6928 return resultobj;
6929 fail:
6930 return NULL;
6931 }
6932
6933
6934 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6935 PyObject *resultobj = 0;
6936 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6937 int *arg2 = (int *) 0 ;
6938 int *arg3 = (int *) 0 ;
6939 void *argp1 = 0 ;
6940 int res1 = 0 ;
6941 int temp2 ;
6942 int res2 = SWIG_TMPOBJ ;
6943 int temp3 ;
6944 int res3 = SWIG_TMPOBJ ;
6945 PyObject *swig_obj[1] ;
6946
6947 arg2 = &temp2;
6948 arg3 = &temp3;
6949 if (!args) SWIG_fail;
6950 swig_obj[0] = args;
6951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6952 if (!SWIG_IsOK(res1)) {
6953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6954 }
6955 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 resultobj = SWIG_Py_Void();
6963 if (SWIG_IsTmpObj(res2)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res3)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6974 }
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6982 PyObject *resultobj = 0;
6983 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6984 int *arg2 = (int *) 0 ;
6985 int *arg3 = (int *) 0 ;
6986 void *argp1 = 0 ;
6987 int res1 = 0 ;
6988 int temp2 ;
6989 int res2 = SWIG_TMPOBJ ;
6990 int temp3 ;
6991 int res3 = SWIG_TMPOBJ ;
6992 PyObject *swig_obj[1] ;
6993
6994 arg2 = &temp2;
6995 arg3 = &temp3;
6996 if (!args) SWIG_fail;
6997 swig_obj[0] = args;
6998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7001 }
7002 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 if (SWIG_IsTmpObj(res2)) {
7011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7012 } else {
7013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7015 }
7016 if (SWIG_IsTmpObj(res3)) {
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7018 } else {
7019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7021 }
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7029 PyObject *resultobj = 0;
7030 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7031 bool result;
7032 void *argp1 = 0 ;
7033 int res1 = 0 ;
7034 PyObject *swig_obj[1] ;
7035
7036 if (!args) SWIG_fail;
7037 swig_obj[0] = args;
7038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7039 if (!SWIG_IsOK(res1)) {
7040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7041 }
7042 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 {
7050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7051 }
7052 return resultobj;
7053 fail:
7054 return NULL;
7055 }
7056
7057
7058 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7059 PyObject *resultobj = 0;
7060 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7061 wxGrid *arg2 = (wxGrid *) 0 ;
7062 int arg3 ;
7063 int arg4 ;
7064 wxGridCellRenderer *result = 0 ;
7065 void *argp1 = 0 ;
7066 int res1 = 0 ;
7067 void *argp2 = 0 ;
7068 int res2 = 0 ;
7069 int val3 ;
7070 int ecode3 = 0 ;
7071 int val4 ;
7072 int ecode4 = 0 ;
7073 PyObject * obj0 = 0 ;
7074 PyObject * obj1 = 0 ;
7075 PyObject * obj2 = 0 ;
7076 PyObject * obj3 = 0 ;
7077 char * kwnames[] = {
7078 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7079 };
7080
7081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7083 if (!SWIG_IsOK(res1)) {
7084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7085 }
7086 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7088 if (!SWIG_IsOK(res2)) {
7089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7090 }
7091 arg2 = reinterpret_cast< wxGrid * >(argp2);
7092 ecode3 = SWIG_AsVal_int(obj2, &val3);
7093 if (!SWIG_IsOK(ecode3)) {
7094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7095 }
7096 arg3 = static_cast< int >(val3);
7097 ecode4 = SWIG_AsVal_int(obj3, &val4);
7098 if (!SWIG_IsOK(ecode4)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7100 }
7101 arg4 = static_cast< int >(val4);
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 {
7109 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7110 }
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj = 0;
7119 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7120 wxGrid *arg2 = (wxGrid *) 0 ;
7121 int arg3 ;
7122 int arg4 ;
7123 wxGridCellEditor *result = 0 ;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 void *argp2 = 0 ;
7127 int res2 = 0 ;
7128 int val3 ;
7129 int ecode3 = 0 ;
7130 int val4 ;
7131 int ecode4 = 0 ;
7132 PyObject * obj0 = 0 ;
7133 PyObject * obj1 = 0 ;
7134 PyObject * obj2 = 0 ;
7135 PyObject * obj3 = 0 ;
7136 char * kwnames[] = {
7137 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7138 };
7139
7140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7144 }
7145 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7147 if (!SWIG_IsOK(res2)) {
7148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7149 }
7150 arg2 = reinterpret_cast< wxGrid * >(argp2);
7151 ecode3 = SWIG_AsVal_int(obj2, &val3);
7152 if (!SWIG_IsOK(ecode3)) {
7153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7154 }
7155 arg3 = static_cast< int >(val3);
7156 ecode4 = SWIG_AsVal_int(obj3, &val4);
7157 if (!SWIG_IsOK(ecode4)) {
7158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7159 }
7160 arg4 = static_cast< int >(val4);
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 {
7168 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7169 }
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7177 PyObject *resultobj = 0;
7178 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7179 bool result;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 PyObject *swig_obj[1] ;
7183
7184 if (!args) SWIG_fail;
7185 swig_obj[0] = args;
7186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7187 if (!SWIG_IsOK(res1)) {
7188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7189 }
7190 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7191 {
7192 PyThreadState* __tstate = wxPyBeginAllowThreads();
7193 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 {
7198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7199 }
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7207 PyObject *resultobj = 0;
7208 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7209 wxGridCellAttr::wxAttrKind result;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 PyObject *swig_obj[1] ;
7213
7214 if (!args) SWIG_fail;
7215 swig_obj[0] = args;
7216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7217 if (!SWIG_IsOK(res1)) {
7218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7219 }
7220 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7221 {
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 resultobj = SWIG_From_int(static_cast< int >(result));
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj = 0;
7236 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7237 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7238 void *argp1 = 0 ;
7239 int res1 = 0 ;
7240 void *argp2 = 0 ;
7241 int res2 = 0 ;
7242 PyObject * obj0 = 0 ;
7243 PyObject * obj1 = 0 ;
7244 char * kwnames[] = {
7245 (char *) "self",(char *) "defAttr", NULL
7246 };
7247
7248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7250 if (!SWIG_IsOK(res1)) {
7251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7252 }
7253 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7255 if (!SWIG_IsOK(res2)) {
7256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7257 }
7258 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 (arg1)->SetDefAttr(arg2);
7262 wxPyEndAllowThreads(__tstate);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_Py_Void();
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7273 PyObject *obj;
7274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7275 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7276 return SWIG_Py_Void();
7277 }
7278
7279 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7280 return SWIG_Python_InitShadowInstance(args);
7281 }
7282
7283 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7284 PyObject *resultobj = 0;
7285 wxGridCellAttrProvider *result = 0 ;
7286
7287 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 {
7295 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7296 }
7297 return resultobj;
7298 fail:
7299 return NULL;
7300 }
7301
7302
7303 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7304 PyObject *resultobj = 0;
7305 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7306 PyObject *arg2 = (PyObject *) 0 ;
7307 void *argp1 = 0 ;
7308 int res1 = 0 ;
7309 PyObject * obj0 = 0 ;
7310 PyObject * obj1 = 0 ;
7311 char * kwnames[] = {
7312 (char *) "self",(char *) "_self", NULL
7313 };
7314
7315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7317 if (!SWIG_IsOK(res1)) {
7318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7319 }
7320 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7321 arg2 = obj1;
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_Py_Void();
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7338 int arg2 ;
7339 int arg3 ;
7340 wxGridCellAttr::wxAttrKind arg4 ;
7341 wxGridCellAttr *result = 0 ;
7342 void *argp1 = 0 ;
7343 int res1 = 0 ;
7344 int val2 ;
7345 int ecode2 = 0 ;
7346 int val3 ;
7347 int ecode3 = 0 ;
7348 int val4 ;
7349 int ecode4 = 0 ;
7350 PyObject * obj0 = 0 ;
7351 PyObject * obj1 = 0 ;
7352 PyObject * obj2 = 0 ;
7353 PyObject * obj3 = 0 ;
7354 char * kwnames[] = {
7355 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7356 };
7357
7358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7362 }
7363 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7364 ecode2 = SWIG_AsVal_int(obj1, &val2);
7365 if (!SWIG_IsOK(ecode2)) {
7366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7367 }
7368 arg2 = static_cast< int >(val2);
7369 ecode3 = SWIG_AsVal_int(obj2, &val3);
7370 if (!SWIG_IsOK(ecode3)) {
7371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7372 }
7373 arg3 = static_cast< int >(val3);
7374 ecode4 = SWIG_AsVal_int(obj3, &val4);
7375 if (!SWIG_IsOK(ecode4)) {
7376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7377 }
7378 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7379 {
7380 PyThreadState* __tstate = wxPyBeginAllowThreads();
7381 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 {
7386 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7387 }
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj = 0;
7396 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7397 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7398 int arg3 ;
7399 int arg4 ;
7400 void *argp1 = 0 ;
7401 int res1 = 0 ;
7402 void *argp2 = 0 ;
7403 int res2 = 0 ;
7404 int val3 ;
7405 int ecode3 = 0 ;
7406 int val4 ;
7407 int ecode4 = 0 ;
7408 PyObject * obj0 = 0 ;
7409 PyObject * obj1 = 0 ;
7410 PyObject * obj2 = 0 ;
7411 PyObject * obj3 = 0 ;
7412 char * kwnames[] = {
7413 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7414 };
7415
7416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7418 if (!SWIG_IsOK(res1)) {
7419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7420 }
7421 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7423 if (!SWIG_IsOK(res2)) {
7424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7425 }
7426 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7427 ecode3 = SWIG_AsVal_int(obj2, &val3);
7428 if (!SWIG_IsOK(ecode3)) {
7429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7430 }
7431 arg3 = static_cast< int >(val3);
7432 ecode4 = SWIG_AsVal_int(obj3, &val4);
7433 if (!SWIG_IsOK(ecode4)) {
7434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7435 }
7436 arg4 = static_cast< int >(val4);
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 (arg1)->SetAttr(arg2,arg3,arg4);
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 resultobj = SWIG_Py_Void();
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj = 0;
7452 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7453 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7454 int arg3 ;
7455 void *argp1 = 0 ;
7456 int res1 = 0 ;
7457 void *argp2 = 0 ;
7458 int res2 = 0 ;
7459 int val3 ;
7460 int ecode3 = 0 ;
7461 PyObject * obj0 = 0 ;
7462 PyObject * obj1 = 0 ;
7463 PyObject * obj2 = 0 ;
7464 char * kwnames[] = {
7465 (char *) "self",(char *) "attr",(char *) "row", NULL
7466 };
7467
7468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7470 if (!SWIG_IsOK(res1)) {
7471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7472 }
7473 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7475 if (!SWIG_IsOK(res2)) {
7476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7477 }
7478 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7479 ecode3 = SWIG_AsVal_int(obj2, &val3);
7480 if (!SWIG_IsOK(ecode3)) {
7481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7482 }
7483 arg3 = static_cast< int >(val3);
7484 {
7485 PyThreadState* __tstate = wxPyBeginAllowThreads();
7486 (arg1)->SetRowAttr(arg2,arg3);
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 resultobj = SWIG_Py_Void();
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj = 0;
7499 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7500 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7501 int arg3 ;
7502 void *argp1 = 0 ;
7503 int res1 = 0 ;
7504 void *argp2 = 0 ;
7505 int res2 = 0 ;
7506 int val3 ;
7507 int ecode3 = 0 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 PyObject * obj2 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "attr",(char *) "col", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7519 }
7520 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7522 if (!SWIG_IsOK(res2)) {
7523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7524 }
7525 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7526 ecode3 = SWIG_AsVal_int(obj2, &val3);
7527 if (!SWIG_IsOK(ecode3)) {
7528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7529 }
7530 arg3 = static_cast< int >(val3);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 (arg1)->SetColAttr(arg2,arg3);
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 resultobj = SWIG_Py_Void();
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7547 size_t arg2 ;
7548 int arg3 ;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 size_t val2 ;
7552 int ecode2 = 0 ;
7553 int val3 ;
7554 int ecode3 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 PyObject * obj2 = 0 ;
7558 char * kwnames[] = {
7559 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7560 };
7561
7562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7566 }
7567 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7568 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7569 if (!SWIG_IsOK(ecode2)) {
7570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7571 }
7572 arg2 = static_cast< size_t >(val2);
7573 ecode3 = SWIG_AsVal_int(obj2, &val3);
7574 if (!SWIG_IsOK(ecode3)) {
7575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7576 }
7577 arg3 = static_cast< int >(val3);
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 (arg1)->UpdateAttrRows(arg2,arg3);
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_Py_Void();
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7594 size_t arg2 ;
7595 int arg3 ;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 size_t val2 ;
7599 int ecode2 = 0 ;
7600 int val3 ;
7601 int ecode3 = 0 ;
7602 PyObject * obj0 = 0 ;
7603 PyObject * obj1 = 0 ;
7604 PyObject * obj2 = 0 ;
7605 char * kwnames[] = {
7606 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7607 };
7608
7609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7611 if (!SWIG_IsOK(res1)) {
7612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7613 }
7614 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7616 if (!SWIG_IsOK(ecode2)) {
7617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7618 }
7619 arg2 = static_cast< size_t >(val2);
7620 ecode3 = SWIG_AsVal_int(obj2, &val3);
7621 if (!SWIG_IsOK(ecode3)) {
7622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7623 }
7624 arg3 = static_cast< int >(val3);
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 (arg1)->UpdateAttrCols(arg2,arg3);
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 resultobj = SWIG_Py_Void();
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7639 PyObject *obj;
7640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7641 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7642 return SWIG_Py_Void();
7643 }
7644
7645 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 return SWIG_Python_InitShadowInstance(args);
7647 }
7648
7649 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 PyObject *resultobj = 0;
7651 wxPyGridCellAttrProvider *result = 0 ;
7652
7653 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7654 {
7655 PyThreadState* __tstate = wxPyBeginAllowThreads();
7656 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7657 wxPyEndAllowThreads(__tstate);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = 0;
7669 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7670 PyObject *arg2 = (PyObject *) 0 ;
7671 PyObject *arg3 = (PyObject *) 0 ;
7672 void *argp1 = 0 ;
7673 int res1 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 PyObject * obj2 = 0 ;
7677 char * kwnames[] = {
7678 (char *) "self",(char *) "self",(char *) "_class", NULL
7679 };
7680
7681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7685 }
7686 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7687 arg2 = obj1;
7688 arg3 = obj2;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 (arg1)->_setCallbackInfo(arg2,arg3);
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 resultobj = SWIG_Py_Void();
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7705 int arg2 ;
7706 int arg3 ;
7707 wxGridCellAttr::wxAttrKind arg4 ;
7708 wxGridCellAttr *result = 0 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 int val2 ;
7712 int ecode2 = 0 ;
7713 int val3 ;
7714 int ecode3 = 0 ;
7715 int val4 ;
7716 int ecode4 = 0 ;
7717 PyObject * obj0 = 0 ;
7718 PyObject * obj1 = 0 ;
7719 PyObject * obj2 = 0 ;
7720 PyObject * obj3 = 0 ;
7721 char * kwnames[] = {
7722 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7723 };
7724
7725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7727 if (!SWIG_IsOK(res1)) {
7728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7729 }
7730 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7731 ecode2 = SWIG_AsVal_int(obj1, &val2);
7732 if (!SWIG_IsOK(ecode2)) {
7733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7734 }
7735 arg2 = static_cast< int >(val2);
7736 ecode3 = SWIG_AsVal_int(obj2, &val3);
7737 if (!SWIG_IsOK(ecode3)) {
7738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7739 }
7740 arg3 = static_cast< int >(val3);
7741 ecode4 = SWIG_AsVal_int(obj3, &val4);
7742 if (!SWIG_IsOK(ecode4)) {
7743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7744 }
7745 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7754 }
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7762 PyObject *resultobj = 0;
7763 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7764 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7765 int arg3 ;
7766 int arg4 ;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 void *argp2 = 0 ;
7770 int res2 = 0 ;
7771 int val3 ;
7772 int ecode3 = 0 ;
7773 int val4 ;
7774 int ecode4 = 0 ;
7775 PyObject * obj0 = 0 ;
7776 PyObject * obj1 = 0 ;
7777 PyObject * obj2 = 0 ;
7778 PyObject * obj3 = 0 ;
7779 char * kwnames[] = {
7780 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7781 };
7782
7783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7785 if (!SWIG_IsOK(res1)) {
7786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7787 }
7788 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7790 if (!SWIG_IsOK(res2)) {
7791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7792 }
7793 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7794 ecode3 = SWIG_AsVal_int(obj2, &val3);
7795 if (!SWIG_IsOK(ecode3)) {
7796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7797 }
7798 arg3 = static_cast< int >(val3);
7799 ecode4 = SWIG_AsVal_int(obj3, &val4);
7800 if (!SWIG_IsOK(ecode4)) {
7801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7802 }
7803 arg4 = static_cast< int >(val4);
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 (arg1)->SetAttr(arg2,arg3,arg4);
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 resultobj = SWIG_Py_Void();
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj = 0;
7819 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7820 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7821 int arg3 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 void *argp2 = 0 ;
7825 int res2 = 0 ;
7826 int val3 ;
7827 int ecode3 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "attr",(char *) "row", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7839 }
7840 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7842 if (!SWIG_IsOK(res2)) {
7843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7844 }
7845 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7846 ecode3 = SWIG_AsVal_int(obj2, &val3);
7847 if (!SWIG_IsOK(ecode3)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7849 }
7850 arg3 = static_cast< int >(val3);
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 (arg1)->SetRowAttr(arg2,arg3);
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj = 0;
7866 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7867 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7868 int arg3 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 void *argp2 = 0 ;
7872 int res2 = 0 ;
7873 int val3 ;
7874 int ecode3 = 0 ;
7875 PyObject * obj0 = 0 ;
7876 PyObject * obj1 = 0 ;
7877 PyObject * obj2 = 0 ;
7878 char * kwnames[] = {
7879 (char *) "self",(char *) "attr",(char *) "col", NULL
7880 };
7881
7882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7884 if (!SWIG_IsOK(res1)) {
7885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7886 }
7887 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7889 if (!SWIG_IsOK(res2)) {
7890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7891 }
7892 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7893 ecode3 = SWIG_AsVal_int(obj2, &val3);
7894 if (!SWIG_IsOK(ecode3)) {
7895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7896 }
7897 arg3 = static_cast< int >(val3);
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 (arg1)->SetColAttr(arg2,arg3);
7901 wxPyEndAllowThreads(__tstate);
7902 if (PyErr_Occurred()) SWIG_fail;
7903 }
7904 resultobj = SWIG_Py_Void();
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 PyObject *obj;
7913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7914 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7915 return SWIG_Py_Void();
7916 }
7917
7918 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 return SWIG_Python_InitShadowInstance(args);
7920 }
7921
7922 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923 PyObject *resultobj = 0;
7924 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7925 void *argp1 = 0 ;
7926 int res1 = 0 ;
7927 PyObject *swig_obj[1] ;
7928
7929 if (!args) SWIG_fail;
7930 swig_obj[0] = args;
7931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7932 if (!SWIG_IsOK(res1)) {
7933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7934 }
7935 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 delete arg1;
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 resultobj = SWIG_Py_Void();
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj = 0;
7952 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7953 PyObject *arg2 = (PyObject *) 0 ;
7954 void *argp1 = 0 ;
7955 int res1 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "self",(char *) "_self", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7964 if (!SWIG_IsOK(res1)) {
7965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7966 }
7967 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7968 arg2 = obj1;
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 wxGridTableBase__setOORInfo(arg1,arg2);
7972 wxPyEndAllowThreads(__tstate);
7973 if (PyErr_Occurred()) SWIG_fail;
7974 }
7975 resultobj = SWIG_Py_Void();
7976 return resultobj;
7977 fail:
7978 return NULL;
7979 }
7980
7981
7982 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7983 PyObject *resultobj = 0;
7984 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7985 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7986 void *argp1 = 0 ;
7987 int res1 = 0 ;
7988 void *argp2 = 0 ;
7989 int res2 = 0 ;
7990 PyObject * obj0 = 0 ;
7991 PyObject * obj1 = 0 ;
7992 char * kwnames[] = {
7993 (char *) "self",(char *) "attrProvider", NULL
7994 };
7995
7996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8000 }
8001 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8003 if (!SWIG_IsOK(res2)) {
8004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8005 }
8006 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8007 {
8008 PyThreadState* __tstate = wxPyBeginAllowThreads();
8009 (arg1)->SetAttrProvider(arg2);
8010 wxPyEndAllowThreads(__tstate);
8011 if (PyErr_Occurred()) SWIG_fail;
8012 }
8013 resultobj = SWIG_Py_Void();
8014 return resultobj;
8015 fail:
8016 return NULL;
8017 }
8018
8019
8020 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8021 PyObject *resultobj = 0;
8022 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8023 wxGridCellAttrProvider *result = 0 ;
8024 void *argp1 = 0 ;
8025 int res1 = 0 ;
8026 PyObject *swig_obj[1] ;
8027
8028 if (!args) SWIG_fail;
8029 swig_obj[0] = args;
8030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8031 if (!SWIG_IsOK(res1)) {
8032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8033 }
8034 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8035 {
8036 PyThreadState* __tstate = wxPyBeginAllowThreads();
8037 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8038 wxPyEndAllowThreads(__tstate);
8039 if (PyErr_Occurred()) SWIG_fail;
8040 }
8041 {
8042 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8043 }
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj = 0;
8052 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8053 wxGrid *arg2 = (wxGrid *) 0 ;
8054 void *argp1 = 0 ;
8055 int res1 = 0 ;
8056 void *argp2 = 0 ;
8057 int res2 = 0 ;
8058 PyObject * obj0 = 0 ;
8059 PyObject * obj1 = 0 ;
8060 char * kwnames[] = {
8061 (char *) "self",(char *) "grid", NULL
8062 };
8063
8064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8066 if (!SWIG_IsOK(res1)) {
8067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8068 }
8069 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8071 if (!SWIG_IsOK(res2)) {
8072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8073 }
8074 arg2 = reinterpret_cast< wxGrid * >(argp2);
8075 {
8076 PyThreadState* __tstate = wxPyBeginAllowThreads();
8077 (arg1)->SetView(arg2);
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 resultobj = SWIG_Py_Void();
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8089 PyObject *resultobj = 0;
8090 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8091 wxGrid *result = 0 ;
8092 void *argp1 = 0 ;
8093 int res1 = 0 ;
8094 PyObject *swig_obj[1] ;
8095
8096 if (!args) SWIG_fail;
8097 swig_obj[0] = args;
8098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8099 if (!SWIG_IsOK(res1)) {
8100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8101 }
8102 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 {
8110 resultobj = wxPyMake_wxObject(result, (bool)0);
8111 }
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119 PyObject *resultobj = 0;
8120 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8121 int result;
8122 void *argp1 = 0 ;
8123 int res1 = 0 ;
8124 PyObject *swig_obj[1] ;
8125
8126 if (!args) SWIG_fail;
8127 swig_obj[0] = args;
8128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8129 if (!SWIG_IsOK(res1)) {
8130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8131 }
8132 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 result = (int)(arg1)->GetNumberRows();
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_From_int(static_cast< int >(result));
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8149 int result;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8159 }
8160 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (int)(arg1)->GetNumberCols();
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 resultobj = SWIG_From_int(static_cast< int >(result));
8168 return resultobj;
8169 fail:
8170 return NULL;
8171 }
8172
8173
8174 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8175 PyObject *resultobj = 0;
8176 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8177 int arg2 ;
8178 int arg3 ;
8179 bool result;
8180 void *argp1 = 0 ;
8181 int res1 = 0 ;
8182 int val2 ;
8183 int ecode2 = 0 ;
8184 int val3 ;
8185 int ecode3 = 0 ;
8186 PyObject * obj0 = 0 ;
8187 PyObject * obj1 = 0 ;
8188 PyObject * obj2 = 0 ;
8189 char * kwnames[] = {
8190 (char *) "self",(char *) "row",(char *) "col", NULL
8191 };
8192
8193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8197 }
8198 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8199 ecode2 = SWIG_AsVal_int(obj1, &val2);
8200 if (!SWIG_IsOK(ecode2)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8202 }
8203 arg2 = static_cast< int >(val2);
8204 ecode3 = SWIG_AsVal_int(obj2, &val3);
8205 if (!SWIG_IsOK(ecode3)) {
8206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8207 }
8208 arg3 = static_cast< int >(val3);
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 {
8216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8217 }
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj = 0;
8226 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8227 int arg2 ;
8228 int arg3 ;
8229 wxString result;
8230 void *argp1 = 0 ;
8231 int res1 = 0 ;
8232 int val2 ;
8233 int ecode2 = 0 ;
8234 int val3 ;
8235 int ecode3 = 0 ;
8236 PyObject * obj0 = 0 ;
8237 PyObject * obj1 = 0 ;
8238 PyObject * obj2 = 0 ;
8239 char * kwnames[] = {
8240 (char *) "self",(char *) "row",(char *) "col", NULL
8241 };
8242
8243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8245 if (!SWIG_IsOK(res1)) {
8246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8247 }
8248 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8249 ecode2 = SWIG_AsVal_int(obj1, &val2);
8250 if (!SWIG_IsOK(ecode2)) {
8251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8252 }
8253 arg2 = static_cast< int >(val2);
8254 ecode3 = SWIG_AsVal_int(obj2, &val3);
8255 if (!SWIG_IsOK(ecode3)) {
8256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8257 }
8258 arg3 = static_cast< int >(val3);
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 result = (arg1)->GetValue(arg2,arg3);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 {
8266 #if wxUSE_UNICODE
8267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8268 #else
8269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8270 #endif
8271 }
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj = 0;
8280 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8281 int arg2 ;
8282 int arg3 ;
8283 wxString *arg4 = 0 ;
8284 void *argp1 = 0 ;
8285 int res1 = 0 ;
8286 int val2 ;
8287 int ecode2 = 0 ;
8288 int val3 ;
8289 int ecode3 = 0 ;
8290 bool temp4 = false ;
8291 PyObject * obj0 = 0 ;
8292 PyObject * obj1 = 0 ;
8293 PyObject * obj2 = 0 ;
8294 PyObject * obj3 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8301 if (!SWIG_IsOK(res1)) {
8302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8303 }
8304 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8305 ecode2 = SWIG_AsVal_int(obj1, &val2);
8306 if (!SWIG_IsOK(ecode2)) {
8307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8308 }
8309 arg2 = static_cast< int >(val2);
8310 ecode3 = SWIG_AsVal_int(obj2, &val3);
8311 if (!SWIG_IsOK(ecode3)) {
8312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8313 }
8314 arg3 = static_cast< int >(val3);
8315 {
8316 arg4 = wxString_in_helper(obj3);
8317 if (arg4 == NULL) SWIG_fail;
8318 temp4 = true;
8319 }
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 resultobj = SWIG_Py_Void();
8327 {
8328 if (temp4)
8329 delete arg4;
8330 }
8331 return resultobj;
8332 fail:
8333 {
8334 if (temp4)
8335 delete arg4;
8336 }
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj = 0;
8343 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8344 int arg2 ;
8345 int arg3 ;
8346 wxString result;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 int val2 ;
8350 int ecode2 = 0 ;
8351 int val3 ;
8352 int ecode3 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 PyObject * obj2 = 0 ;
8356 char * kwnames[] = {
8357 (char *) "self",(char *) "row",(char *) "col", NULL
8358 };
8359
8360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8362 if (!SWIG_IsOK(res1)) {
8363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8364 }
8365 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8366 ecode2 = SWIG_AsVal_int(obj1, &val2);
8367 if (!SWIG_IsOK(ecode2)) {
8368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8369 }
8370 arg2 = static_cast< int >(val2);
8371 ecode3 = SWIG_AsVal_int(obj2, &val3);
8372 if (!SWIG_IsOK(ecode3)) {
8373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8374 }
8375 arg3 = static_cast< int >(val3);
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (arg1)->GetTypeName(arg2,arg3);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 {
8383 #if wxUSE_UNICODE
8384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8385 #else
8386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8387 #endif
8388 }
8389 return resultobj;
8390 fail:
8391 return NULL;
8392 }
8393
8394
8395 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8396 PyObject *resultobj = 0;
8397 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8398 int arg2 ;
8399 int arg3 ;
8400 wxString *arg4 = 0 ;
8401 bool result;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 int val2 ;
8405 int ecode2 = 0 ;
8406 int val3 ;
8407 int ecode3 = 0 ;
8408 bool temp4 = false ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 PyObject * obj2 = 0 ;
8412 PyObject * obj3 = 0 ;
8413 char * kwnames[] = {
8414 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8415 };
8416
8417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8419 if (!SWIG_IsOK(res1)) {
8420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8421 }
8422 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8423 ecode2 = SWIG_AsVal_int(obj1, &val2);
8424 if (!SWIG_IsOK(ecode2)) {
8425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8426 }
8427 arg2 = static_cast< int >(val2);
8428 ecode3 = SWIG_AsVal_int(obj2, &val3);
8429 if (!SWIG_IsOK(ecode3)) {
8430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8431 }
8432 arg3 = static_cast< int >(val3);
8433 {
8434 arg4 = wxString_in_helper(obj3);
8435 if (arg4 == NULL) SWIG_fail;
8436 temp4 = true;
8437 }
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8446 }
8447 {
8448 if (temp4)
8449 delete arg4;
8450 }
8451 return resultobj;
8452 fail:
8453 {
8454 if (temp4)
8455 delete arg4;
8456 }
8457 return NULL;
8458 }
8459
8460
8461 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8462 PyObject *resultobj = 0;
8463 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8464 int arg2 ;
8465 int arg3 ;
8466 wxString *arg4 = 0 ;
8467 bool result;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 int val2 ;
8471 int ecode2 = 0 ;
8472 int val3 ;
8473 int ecode3 = 0 ;
8474 bool temp4 = false ;
8475 PyObject * obj0 = 0 ;
8476 PyObject * obj1 = 0 ;
8477 PyObject * obj2 = 0 ;
8478 PyObject * obj3 = 0 ;
8479 char * kwnames[] = {
8480 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8481 };
8482
8483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8487 }
8488 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8489 ecode2 = SWIG_AsVal_int(obj1, &val2);
8490 if (!SWIG_IsOK(ecode2)) {
8491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8492 }
8493 arg2 = static_cast< int >(val2);
8494 ecode3 = SWIG_AsVal_int(obj2, &val3);
8495 if (!SWIG_IsOK(ecode3)) {
8496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8497 }
8498 arg3 = static_cast< int >(val3);
8499 {
8500 arg4 = wxString_in_helper(obj3);
8501 if (arg4 == NULL) SWIG_fail;
8502 temp4 = true;
8503 }
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8507 wxPyEndAllowThreads(__tstate);
8508 if (PyErr_Occurred()) SWIG_fail;
8509 }
8510 {
8511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8512 }
8513 {
8514 if (temp4)
8515 delete arg4;
8516 }
8517 return resultobj;
8518 fail:
8519 {
8520 if (temp4)
8521 delete arg4;
8522 }
8523 return NULL;
8524 }
8525
8526
8527 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8528 PyObject *resultobj = 0;
8529 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8530 int arg2 ;
8531 int arg3 ;
8532 long result;
8533 void *argp1 = 0 ;
8534 int res1 = 0 ;
8535 int val2 ;
8536 int ecode2 = 0 ;
8537 int val3 ;
8538 int ecode3 = 0 ;
8539 PyObject * obj0 = 0 ;
8540 PyObject * obj1 = 0 ;
8541 PyObject * obj2 = 0 ;
8542 char * kwnames[] = {
8543 (char *) "self",(char *) "row",(char *) "col", NULL
8544 };
8545
8546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8548 if (!SWIG_IsOK(res1)) {
8549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8550 }
8551 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8552 ecode2 = SWIG_AsVal_int(obj1, &val2);
8553 if (!SWIG_IsOK(ecode2)) {
8554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8555 }
8556 arg2 = static_cast< int >(val2);
8557 ecode3 = SWIG_AsVal_int(obj2, &val3);
8558 if (!SWIG_IsOK(ecode3)) {
8559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8560 }
8561 arg3 = static_cast< int >(val3);
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_From_long(static_cast< long >(result));
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8578 int arg2 ;
8579 int arg3 ;
8580 double result;
8581 void *argp1 = 0 ;
8582 int res1 = 0 ;
8583 int val2 ;
8584 int ecode2 = 0 ;
8585 int val3 ;
8586 int ecode3 = 0 ;
8587 PyObject * obj0 = 0 ;
8588 PyObject * obj1 = 0 ;
8589 PyObject * obj2 = 0 ;
8590 char * kwnames[] = {
8591 (char *) "self",(char *) "row",(char *) "col", NULL
8592 };
8593
8594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8596 if (!SWIG_IsOK(res1)) {
8597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8598 }
8599 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8600 ecode2 = SWIG_AsVal_int(obj1, &val2);
8601 if (!SWIG_IsOK(ecode2)) {
8602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8603 }
8604 arg2 = static_cast< int >(val2);
8605 ecode3 = SWIG_AsVal_int(obj2, &val3);
8606 if (!SWIG_IsOK(ecode3)) {
8607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8608 }
8609 arg3 = static_cast< int >(val3);
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 resultobj = SWIG_From_double(static_cast< double >(result));
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj = 0;
8625 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8626 int arg2 ;
8627 int arg3 ;
8628 bool result;
8629 void *argp1 = 0 ;
8630 int res1 = 0 ;
8631 int val2 ;
8632 int ecode2 = 0 ;
8633 int val3 ;
8634 int ecode3 = 0 ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637 PyObject * obj2 = 0 ;
8638 char * kwnames[] = {
8639 (char *) "self",(char *) "row",(char *) "col", NULL
8640 };
8641
8642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8644 if (!SWIG_IsOK(res1)) {
8645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8646 }
8647 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8648 ecode2 = SWIG_AsVal_int(obj1, &val2);
8649 if (!SWIG_IsOK(ecode2)) {
8650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8651 }
8652 arg2 = static_cast< int >(val2);
8653 ecode3 = SWIG_AsVal_int(obj2, &val3);
8654 if (!SWIG_IsOK(ecode3)) {
8655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8656 }
8657 arg3 = static_cast< int >(val3);
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 {
8665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8666 }
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj = 0;
8675 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8676 int arg2 ;
8677 int arg3 ;
8678 long arg4 ;
8679 void *argp1 = 0 ;
8680 int res1 = 0 ;
8681 int val2 ;
8682 int ecode2 = 0 ;
8683 int val3 ;
8684 int ecode3 = 0 ;
8685 long val4 ;
8686 int ecode4 = 0 ;
8687 PyObject * obj0 = 0 ;
8688 PyObject * obj1 = 0 ;
8689 PyObject * obj2 = 0 ;
8690 PyObject * obj3 = 0 ;
8691 char * kwnames[] = {
8692 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8693 };
8694
8695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8697 if (!SWIG_IsOK(res1)) {
8698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8699 }
8700 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8701 ecode2 = SWIG_AsVal_int(obj1, &val2);
8702 if (!SWIG_IsOK(ecode2)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8704 }
8705 arg2 = static_cast< int >(val2);
8706 ecode3 = SWIG_AsVal_int(obj2, &val3);
8707 if (!SWIG_IsOK(ecode3)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8709 }
8710 arg3 = static_cast< int >(val3);
8711 ecode4 = SWIG_AsVal_long(obj3, &val4);
8712 if (!SWIG_IsOK(ecode4)) {
8713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8714 }
8715 arg4 = static_cast< long >(val4);
8716 {
8717 PyThreadState* __tstate = wxPyBeginAllowThreads();
8718 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8719 wxPyEndAllowThreads(__tstate);
8720 if (PyErr_Occurred()) SWIG_fail;
8721 }
8722 resultobj = SWIG_Py_Void();
8723 return resultobj;
8724 fail:
8725 return NULL;
8726 }
8727
8728
8729 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8730 PyObject *resultobj = 0;
8731 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8732 int arg2 ;
8733 int arg3 ;
8734 double arg4 ;
8735 void *argp1 = 0 ;
8736 int res1 = 0 ;
8737 int val2 ;
8738 int ecode2 = 0 ;
8739 int val3 ;
8740 int ecode3 = 0 ;
8741 double val4 ;
8742 int ecode4 = 0 ;
8743 PyObject * obj0 = 0 ;
8744 PyObject * obj1 = 0 ;
8745 PyObject * obj2 = 0 ;
8746 PyObject * obj3 = 0 ;
8747 char * kwnames[] = {
8748 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8749 };
8750
8751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8753 if (!SWIG_IsOK(res1)) {
8754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8755 }
8756 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8757 ecode2 = SWIG_AsVal_int(obj1, &val2);
8758 if (!SWIG_IsOK(ecode2)) {
8759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8760 }
8761 arg2 = static_cast< int >(val2);
8762 ecode3 = SWIG_AsVal_int(obj2, &val3);
8763 if (!SWIG_IsOK(ecode3)) {
8764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8765 }
8766 arg3 = static_cast< int >(val3);
8767 ecode4 = SWIG_AsVal_double(obj3, &val4);
8768 if (!SWIG_IsOK(ecode4)) {
8769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8770 }
8771 arg4 = static_cast< double >(val4);
8772 {
8773 PyThreadState* __tstate = wxPyBeginAllowThreads();
8774 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8775 wxPyEndAllowThreads(__tstate);
8776 if (PyErr_Occurred()) SWIG_fail;
8777 }
8778 resultobj = SWIG_Py_Void();
8779 return resultobj;
8780 fail:
8781 return NULL;
8782 }
8783
8784
8785 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8786 PyObject *resultobj = 0;
8787 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8788 int arg2 ;
8789 int arg3 ;
8790 bool arg4 ;
8791 void *argp1 = 0 ;
8792 int res1 = 0 ;
8793 int val2 ;
8794 int ecode2 = 0 ;
8795 int val3 ;
8796 int ecode3 = 0 ;
8797 bool val4 ;
8798 int ecode4 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 PyObject * obj3 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8811 }
8812 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8813 ecode2 = SWIG_AsVal_int(obj1, &val2);
8814 if (!SWIG_IsOK(ecode2)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8816 }
8817 arg2 = static_cast< int >(val2);
8818 ecode3 = SWIG_AsVal_int(obj2, &val3);
8819 if (!SWIG_IsOK(ecode3)) {
8820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8821 }
8822 arg3 = static_cast< int >(val3);
8823 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8824 if (!SWIG_IsOK(ecode4)) {
8825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8826 }
8827 arg4 = static_cast< bool >(val4);
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 resultobj = SWIG_Py_Void();
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8842 PyObject *resultobj = 0;
8843 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8844 void *argp1 = 0 ;
8845 int res1 = 0 ;
8846 PyObject *swig_obj[1] ;
8847
8848 if (!args) SWIG_fail;
8849 swig_obj[0] = args;
8850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8853 }
8854 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 (arg1)->Clear();
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_Py_Void();
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj = 0;
8870 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8871 size_t arg2 = (size_t) 0 ;
8872 size_t arg3 = (size_t) 1 ;
8873 bool result;
8874 void *argp1 = 0 ;
8875 int res1 = 0 ;
8876 size_t val2 ;
8877 int ecode2 = 0 ;
8878 size_t val3 ;
8879 int ecode3 = 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 PyObject * obj2 = 0 ;
8883 char * kwnames[] = {
8884 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8885 };
8886
8887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8889 if (!SWIG_IsOK(res1)) {
8890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8891 }
8892 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8893 if (obj1) {
8894 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8895 if (!SWIG_IsOK(ecode2)) {
8896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8897 }
8898 arg2 = static_cast< size_t >(val2);
8899 }
8900 if (obj2) {
8901 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8902 if (!SWIG_IsOK(ecode3)) {
8903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8904 }
8905 arg3 = static_cast< size_t >(val3);
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 result = (bool)(arg1)->InsertRows(arg2,arg3);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 {
8914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8915 }
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj = 0;
8924 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8925 size_t arg2 = (size_t) 1 ;
8926 bool result;
8927 void *argp1 = 0 ;
8928 int res1 = 0 ;
8929 size_t val2 ;
8930 int ecode2 = 0 ;
8931 PyObject * obj0 = 0 ;
8932 PyObject * obj1 = 0 ;
8933 char * kwnames[] = {
8934 (char *) "self",(char *) "numRows", NULL
8935 };
8936
8937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8939 if (!SWIG_IsOK(res1)) {
8940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8941 }
8942 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8943 if (obj1) {
8944 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8945 if (!SWIG_IsOK(ecode2)) {
8946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8947 }
8948 arg2 = static_cast< size_t >(val2);
8949 }
8950 {
8951 PyThreadState* __tstate = wxPyBeginAllowThreads();
8952 result = (bool)(arg1)->AppendRows(arg2);
8953 wxPyEndAllowThreads(__tstate);
8954 if (PyErr_Occurred()) SWIG_fail;
8955 }
8956 {
8957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8958 }
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = 0;
8967 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8968 size_t arg2 = (size_t) 0 ;
8969 size_t arg3 = (size_t) 1 ;
8970 bool result;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 size_t val2 ;
8974 int ecode2 = 0 ;
8975 size_t val3 ;
8976 int ecode3 = 0 ;
8977 PyObject * obj0 = 0 ;
8978 PyObject * obj1 = 0 ;
8979 PyObject * obj2 = 0 ;
8980 char * kwnames[] = {
8981 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8982 };
8983
8984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8986 if (!SWIG_IsOK(res1)) {
8987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8988 }
8989 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8990 if (obj1) {
8991 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8992 if (!SWIG_IsOK(ecode2)) {
8993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8994 }
8995 arg2 = static_cast< size_t >(val2);
8996 }
8997 if (obj2) {
8998 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8999 if (!SWIG_IsOK(ecode3)) {
9000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
9001 }
9002 arg3 = static_cast< size_t >(val3);
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 {
9011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9012 }
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = 0;
9021 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9022 size_t arg2 = (size_t) 0 ;
9023 size_t arg3 = (size_t) 1 ;
9024 bool result;
9025 void *argp1 = 0 ;
9026 int res1 = 0 ;
9027 size_t val2 ;
9028 int ecode2 = 0 ;
9029 size_t val3 ;
9030 int ecode3 = 0 ;
9031 PyObject * obj0 = 0 ;
9032 PyObject * obj1 = 0 ;
9033 PyObject * obj2 = 0 ;
9034 char * kwnames[] = {
9035 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9036 };
9037
9038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9040 if (!SWIG_IsOK(res1)) {
9041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9042 }
9043 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9044 if (obj1) {
9045 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9046 if (!SWIG_IsOK(ecode2)) {
9047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9048 }
9049 arg2 = static_cast< size_t >(val2);
9050 }
9051 if (obj2) {
9052 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9053 if (!SWIG_IsOK(ecode3)) {
9054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9055 }
9056 arg3 = static_cast< size_t >(val3);
9057 }
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 result = (bool)(arg1)->InsertCols(arg2,arg3);
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 {
9065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9066 }
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj = 0;
9075 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9076 size_t arg2 = (size_t) 1 ;
9077 bool result;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 size_t val2 ;
9081 int ecode2 = 0 ;
9082 PyObject * obj0 = 0 ;
9083 PyObject * obj1 = 0 ;
9084 char * kwnames[] = {
9085 (char *) "self",(char *) "numCols", NULL
9086 };
9087
9088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9092 }
9093 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9094 if (obj1) {
9095 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9096 if (!SWIG_IsOK(ecode2)) {
9097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9098 }
9099 arg2 = static_cast< size_t >(val2);
9100 }
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (bool)(arg1)->AppendCols(arg2);
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 {
9108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9109 }
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9119 size_t arg2 = (size_t) 0 ;
9120 size_t arg3 = (size_t) 1 ;
9121 bool result;
9122 void *argp1 = 0 ;
9123 int res1 = 0 ;
9124 size_t val2 ;
9125 int ecode2 = 0 ;
9126 size_t val3 ;
9127 int ecode3 = 0 ;
9128 PyObject * obj0 = 0 ;
9129 PyObject * obj1 = 0 ;
9130 PyObject * obj2 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9137 if (!SWIG_IsOK(res1)) {
9138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9139 }
9140 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9141 if (obj1) {
9142 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9143 if (!SWIG_IsOK(ecode2)) {
9144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9145 }
9146 arg2 = static_cast< size_t >(val2);
9147 }
9148 if (obj2) {
9149 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9150 if (!SWIG_IsOK(ecode3)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9152 }
9153 arg3 = static_cast< size_t >(val3);
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9158 wxPyEndAllowThreads(__tstate);
9159 if (PyErr_Occurred()) SWIG_fail;
9160 }
9161 {
9162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9163 }
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9171 PyObject *resultobj = 0;
9172 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9173 int arg2 ;
9174 wxString result;
9175 void *argp1 = 0 ;
9176 int res1 = 0 ;
9177 int val2 ;
9178 int ecode2 = 0 ;
9179 PyObject * obj0 = 0 ;
9180 PyObject * obj1 = 0 ;
9181 char * kwnames[] = {
9182 (char *) "self",(char *) "row", NULL
9183 };
9184
9185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9189 }
9190 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9191 ecode2 = SWIG_AsVal_int(obj1, &val2);
9192 if (!SWIG_IsOK(ecode2)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9194 }
9195 arg2 = static_cast< int >(val2);
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 result = (arg1)->GetRowLabelValue(arg2);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 {
9203 #if wxUSE_UNICODE
9204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9205 #else
9206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9207 #endif
9208 }
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj = 0;
9217 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9218 int arg2 ;
9219 wxString result;
9220 void *argp1 = 0 ;
9221 int res1 = 0 ;
9222 int val2 ;
9223 int ecode2 = 0 ;
9224 PyObject * obj0 = 0 ;
9225 PyObject * obj1 = 0 ;
9226 char * kwnames[] = {
9227 (char *) "self",(char *) "col", NULL
9228 };
9229
9230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9232 if (!SWIG_IsOK(res1)) {
9233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9234 }
9235 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9236 ecode2 = SWIG_AsVal_int(obj1, &val2);
9237 if (!SWIG_IsOK(ecode2)) {
9238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9239 }
9240 arg2 = static_cast< int >(val2);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 result = (arg1)->GetColLabelValue(arg2);
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 {
9248 #if wxUSE_UNICODE
9249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9250 #else
9251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9252 #endif
9253 }
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj = 0;
9262 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9263 int arg2 ;
9264 wxString *arg3 = 0 ;
9265 void *argp1 = 0 ;
9266 int res1 = 0 ;
9267 int val2 ;
9268 int ecode2 = 0 ;
9269 bool temp3 = false ;
9270 PyObject * obj0 = 0 ;
9271 PyObject * obj1 = 0 ;
9272 PyObject * obj2 = 0 ;
9273 char * kwnames[] = {
9274 (char *) "self",(char *) "row",(char *) "value", NULL
9275 };
9276
9277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9279 if (!SWIG_IsOK(res1)) {
9280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9281 }
9282 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9283 ecode2 = SWIG_AsVal_int(obj1, &val2);
9284 if (!SWIG_IsOK(ecode2)) {
9285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9286 }
9287 arg2 = static_cast< int >(val2);
9288 {
9289 arg3 = wxString_in_helper(obj2);
9290 if (arg3 == NULL) SWIG_fail;
9291 temp3 = true;
9292 }
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_Py_Void();
9300 {
9301 if (temp3)
9302 delete arg3;
9303 }
9304 return resultobj;
9305 fail:
9306 {
9307 if (temp3)
9308 delete arg3;
9309 }
9310 return NULL;
9311 }
9312
9313
9314 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj = 0;
9316 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9317 int arg2 ;
9318 wxString *arg3 = 0 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 int val2 ;
9322 int ecode2 = 0 ;
9323 bool temp3 = false ;
9324 PyObject * obj0 = 0 ;
9325 PyObject * obj1 = 0 ;
9326 PyObject * obj2 = 0 ;
9327 char * kwnames[] = {
9328 (char *) "self",(char *) "col",(char *) "value", NULL
9329 };
9330
9331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9333 if (!SWIG_IsOK(res1)) {
9334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9335 }
9336 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9337 ecode2 = SWIG_AsVal_int(obj1, &val2);
9338 if (!SWIG_IsOK(ecode2)) {
9339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9340 }
9341 arg2 = static_cast< int >(val2);
9342 {
9343 arg3 = wxString_in_helper(obj2);
9344 if (arg3 == NULL) SWIG_fail;
9345 temp3 = true;
9346 }
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_Py_Void();
9354 {
9355 if (temp3)
9356 delete arg3;
9357 }
9358 return resultobj;
9359 fail:
9360 {
9361 if (temp3)
9362 delete arg3;
9363 }
9364 return NULL;
9365 }
9366
9367
9368 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9369 PyObject *resultobj = 0;
9370 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9371 bool result;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 PyObject *swig_obj[1] ;
9375
9376 if (!args) SWIG_fail;
9377 swig_obj[0] = args;
9378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9381 }
9382 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 result = (bool)(arg1)->CanHaveAttributes();
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9391 }
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj = 0;
9400 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9401 int arg2 ;
9402 int arg3 ;
9403 wxGridCellAttr::wxAttrKind arg4 ;
9404 wxGridCellAttr *result = 0 ;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 int val2 ;
9408 int ecode2 = 0 ;
9409 int val3 ;
9410 int ecode3 = 0 ;
9411 int val4 ;
9412 int ecode4 = 0 ;
9413 PyObject * obj0 = 0 ;
9414 PyObject * obj1 = 0 ;
9415 PyObject * obj2 = 0 ;
9416 PyObject * obj3 = 0 ;
9417 char * kwnames[] = {
9418 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9419 };
9420
9421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9423 if (!SWIG_IsOK(res1)) {
9424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9425 }
9426 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9427 ecode2 = SWIG_AsVal_int(obj1, &val2);
9428 if (!SWIG_IsOK(ecode2)) {
9429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9430 }
9431 arg2 = static_cast< int >(val2);
9432 ecode3 = SWIG_AsVal_int(obj2, &val3);
9433 if (!SWIG_IsOK(ecode3)) {
9434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9435 }
9436 arg3 = static_cast< int >(val3);
9437 ecode4 = SWIG_AsVal_int(obj3, &val4);
9438 if (!SWIG_IsOK(ecode4)) {
9439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9440 }
9441 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9442 {
9443 PyThreadState* __tstate = wxPyBeginAllowThreads();
9444 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9445 wxPyEndAllowThreads(__tstate);
9446 if (PyErr_Occurred()) SWIG_fail;
9447 }
9448 {
9449 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9450 }
9451 return resultobj;
9452 fail:
9453 return NULL;
9454 }
9455
9456
9457 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj = 0;
9459 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9460 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9461 int arg3 ;
9462 int arg4 ;
9463 void *argp1 = 0 ;
9464 int res1 = 0 ;
9465 void *argp2 = 0 ;
9466 int res2 = 0 ;
9467 int val3 ;
9468 int ecode3 = 0 ;
9469 int val4 ;
9470 int ecode4 = 0 ;
9471 PyObject * obj0 = 0 ;
9472 PyObject * obj1 = 0 ;
9473 PyObject * obj2 = 0 ;
9474 PyObject * obj3 = 0 ;
9475 char * kwnames[] = {
9476 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9477 };
9478
9479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9481 if (!SWIG_IsOK(res1)) {
9482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9483 }
9484 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9486 if (!SWIG_IsOK(res2)) {
9487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9488 }
9489 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9490 ecode3 = SWIG_AsVal_int(obj2, &val3);
9491 if (!SWIG_IsOK(ecode3)) {
9492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9493 }
9494 arg3 = static_cast< int >(val3);
9495 ecode4 = SWIG_AsVal_int(obj3, &val4);
9496 if (!SWIG_IsOK(ecode4)) {
9497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9498 }
9499 arg4 = static_cast< int >(val4);
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 (arg1)->SetAttr(arg2,arg3,arg4);
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9514 PyObject *resultobj = 0;
9515 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9516 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9517 int arg3 ;
9518 void *argp1 = 0 ;
9519 int res1 = 0 ;
9520 void *argp2 = 0 ;
9521 int res2 = 0 ;
9522 int val3 ;
9523 int ecode3 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 PyObject * obj2 = 0 ;
9527 char * kwnames[] = {
9528 (char *) "self",(char *) "attr",(char *) "row", NULL
9529 };
9530
9531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9533 if (!SWIG_IsOK(res1)) {
9534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9535 }
9536 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9538 if (!SWIG_IsOK(res2)) {
9539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9540 }
9541 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9542 ecode3 = SWIG_AsVal_int(obj2, &val3);
9543 if (!SWIG_IsOK(ecode3)) {
9544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9545 }
9546 arg3 = static_cast< int >(val3);
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 (arg1)->SetRowAttr(arg2,arg3);
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_Py_Void();
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9563 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9564 int arg3 ;
9565 void *argp1 = 0 ;
9566 int res1 = 0 ;
9567 void *argp2 = 0 ;
9568 int res2 = 0 ;
9569 int val3 ;
9570 int ecode3 = 0 ;
9571 PyObject * obj0 = 0 ;
9572 PyObject * obj1 = 0 ;
9573 PyObject * obj2 = 0 ;
9574 char * kwnames[] = {
9575 (char *) "self",(char *) "attr",(char *) "col", NULL
9576 };
9577
9578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9580 if (!SWIG_IsOK(res1)) {
9581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9582 }
9583 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9585 if (!SWIG_IsOK(res2)) {
9586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9587 }
9588 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9589 ecode3 = SWIG_AsVal_int(obj2, &val3);
9590 if (!SWIG_IsOK(ecode3)) {
9591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9592 }
9593 arg3 = static_cast< int >(val3);
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 (arg1)->SetColAttr(arg2,arg3);
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_Py_Void();
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *obj;
9609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9610 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9611 return SWIG_Py_Void();
9612 }
9613
9614 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9615 PyObject *resultobj = 0;
9616 wxPyGridTableBase *result = 0 ;
9617
9618 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9626 return resultobj;
9627 fail:
9628 return NULL;
9629 }
9630
9631
9632 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9633 PyObject *resultobj = 0;
9634 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9635 PyObject *arg2 = (PyObject *) 0 ;
9636 PyObject *arg3 = (PyObject *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 PyObject * obj2 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "self",(char *) "_class", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9650 }
9651 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9652 arg2 = obj1;
9653 arg3 = obj2;
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->_setCallbackInfo(arg2,arg3);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 PyObject *resultobj = 0;
9669 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9679 }
9680 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 wxPyGridTableBase_Destroy(arg1);
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_Py_Void();
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9702 return SWIG_Python_InitShadowInstance(args);
9703 }
9704
9705 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9706 PyObject *resultobj = 0;
9707 int arg1 = (int) 0 ;
9708 int arg2 = (int) 0 ;
9709 wxGridStringTable *result = 0 ;
9710 int val1 ;
9711 int ecode1 = 0 ;
9712 int val2 ;
9713 int ecode2 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 char * kwnames[] = {
9717 (char *) "numRows",(char *) "numCols", NULL
9718 };
9719
9720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9721 if (obj0) {
9722 ecode1 = SWIG_AsVal_int(obj0, &val1);
9723 if (!SWIG_IsOK(ecode1)) {
9724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9725 }
9726 arg1 = static_cast< int >(val1);
9727 }
9728 if (obj1) {
9729 ecode2 = SWIG_AsVal_int(obj1, &val2);
9730 if (!SWIG_IsOK(ecode2)) {
9731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9732 }
9733 arg2 = static_cast< int >(val2);
9734 }
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9749 PyObject *obj;
9750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9751 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9752 return SWIG_Py_Void();
9753 }
9754
9755 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 return SWIG_Python_InitShadowInstance(args);
9757 }
9758
9759 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9760 PyObject *resultobj = 0;
9761 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9762 int arg2 ;
9763 int arg3 = (int) -1 ;
9764 int arg4 = (int) -1 ;
9765 wxGridTableMessage *result = 0 ;
9766 void *argp1 = 0 ;
9767 int res1 = 0 ;
9768 int val2 ;
9769 int ecode2 = 0 ;
9770 int val3 ;
9771 int ecode3 = 0 ;
9772 int val4 ;
9773 int ecode4 = 0 ;
9774 PyObject * obj0 = 0 ;
9775 PyObject * obj1 = 0 ;
9776 PyObject * obj2 = 0 ;
9777 PyObject * obj3 = 0 ;
9778 char * kwnames[] = {
9779 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9780 };
9781
9782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9784 if (!SWIG_IsOK(res1)) {
9785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9786 }
9787 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9788 ecode2 = SWIG_AsVal_int(obj1, &val2);
9789 if (!SWIG_IsOK(ecode2)) {
9790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9791 }
9792 arg2 = static_cast< int >(val2);
9793 if (obj2) {
9794 ecode3 = SWIG_AsVal_int(obj2, &val3);
9795 if (!SWIG_IsOK(ecode3)) {
9796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9797 }
9798 arg3 = static_cast< int >(val3);
9799 }
9800 if (obj3) {
9801 ecode4 = SWIG_AsVal_int(obj3, &val4);
9802 if (!SWIG_IsOK(ecode4)) {
9803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9804 }
9805 arg4 = static_cast< int >(val4);
9806 }
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9821 PyObject *resultobj = 0;
9822 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9823 void *argp1 = 0 ;
9824 int res1 = 0 ;
9825 PyObject *swig_obj[1] ;
9826
9827 if (!args) SWIG_fail;
9828 swig_obj[0] = args;
9829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9830 if (!SWIG_IsOK(res1)) {
9831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9832 }
9833 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 delete arg1;
9837
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 resultobj = SWIG_Py_Void();
9842 return resultobj;
9843 fail:
9844 return NULL;
9845 }
9846
9847
9848 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj = 0;
9850 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9851 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9852 void *argp1 = 0 ;
9853 int res1 = 0 ;
9854 void *argp2 = 0 ;
9855 int res2 = 0 ;
9856 PyObject * obj0 = 0 ;
9857 PyObject * obj1 = 0 ;
9858 char * kwnames[] = {
9859 (char *) "self",(char *) "table", NULL
9860 };
9861
9862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9864 if (!SWIG_IsOK(res1)) {
9865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9866 }
9867 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9869 if (!SWIG_IsOK(res2)) {
9870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9871 }
9872 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 (arg1)->SetTableObject(arg2);
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 resultobj = SWIG_Py_Void();
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *resultobj = 0;
9888 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9889 wxGridTableBase *result = 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject *swig_obj[1] ;
9893
9894 if (!args) SWIG_fail;
9895 swig_obj[0] = args;
9896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9897 if (!SWIG_IsOK(res1)) {
9898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9899 }
9900 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9909 }
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj = 0;
9918 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9919 int arg2 ;
9920 void *argp1 = 0 ;
9921 int res1 = 0 ;
9922 int val2 ;
9923 int ecode2 = 0 ;
9924 PyObject * obj0 = 0 ;
9925 PyObject * obj1 = 0 ;
9926 char * kwnames[] = {
9927 (char *) "self",(char *) "id", NULL
9928 };
9929
9930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9932 if (!SWIG_IsOK(res1)) {
9933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9934 }
9935 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9936 ecode2 = SWIG_AsVal_int(obj1, &val2);
9937 if (!SWIG_IsOK(ecode2)) {
9938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9939 }
9940 arg2 = static_cast< int >(val2);
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 (arg1)->SetId(arg2);
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_Py_Void();
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9955 PyObject *resultobj = 0;
9956 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9957 int result;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 PyObject *swig_obj[1] ;
9961
9962 if (!args) SWIG_fail;
9963 swig_obj[0] = args;
9964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9965 if (!SWIG_IsOK(res1)) {
9966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9967 }
9968 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (int)(arg1)->GetId();
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 resultobj = SWIG_From_int(static_cast< int >(result));
9976 return resultobj;
9977 fail:
9978 return NULL;
9979 }
9980
9981
9982 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9983 PyObject *resultobj = 0;
9984 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9985 int arg2 ;
9986 void *argp1 = 0 ;
9987 int res1 = 0 ;
9988 int val2 ;
9989 int ecode2 = 0 ;
9990 PyObject * obj0 = 0 ;
9991 PyObject * obj1 = 0 ;
9992 char * kwnames[] = {
9993 (char *) "self",(char *) "comInt1", NULL
9994 };
9995
9996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10000 }
10001 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10002 ecode2 = SWIG_AsVal_int(obj1, &val2);
10003 if (!SWIG_IsOK(ecode2)) {
10004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10005 }
10006 arg2 = static_cast< int >(val2);
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 (arg1)->SetCommandInt(arg2);
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_Py_Void();
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10023 int result;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 PyObject *swig_obj[1] ;
10027
10028 if (!args) SWIG_fail;
10029 swig_obj[0] = args;
10030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10033 }
10034 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10035 {
10036 PyThreadState* __tstate = wxPyBeginAllowThreads();
10037 result = (int)(arg1)->GetCommandInt();
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 resultobj = SWIG_From_int(static_cast< int >(result));
10042 return resultobj;
10043 fail:
10044 return NULL;
10045 }
10046
10047
10048 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10049 PyObject *resultobj = 0;
10050 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10051 int arg2 ;
10052 void *argp1 = 0 ;
10053 int res1 = 0 ;
10054 int val2 ;
10055 int ecode2 = 0 ;
10056 PyObject * obj0 = 0 ;
10057 PyObject * obj1 = 0 ;
10058 char * kwnames[] = {
10059 (char *) "self",(char *) "comInt2", NULL
10060 };
10061
10062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10066 }
10067 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10068 ecode2 = SWIG_AsVal_int(obj1, &val2);
10069 if (!SWIG_IsOK(ecode2)) {
10070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10071 }
10072 arg2 = static_cast< int >(val2);
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 (arg1)->SetCommandInt2(arg2);
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 resultobj = SWIG_Py_Void();
10080 return resultobj;
10081 fail:
10082 return NULL;
10083 }
10084
10085
10086 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10087 PyObject *resultobj = 0;
10088 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10089 int result;
10090 void *argp1 = 0 ;
10091 int res1 = 0 ;
10092 PyObject *swig_obj[1] ;
10093
10094 if (!args) SWIG_fail;
10095 swig_obj[0] = args;
10096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10099 }
10100 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 result = (int)(arg1)->GetCommandInt2();
10104 wxPyEndAllowThreads(__tstate);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 resultobj = SWIG_From_int(static_cast< int >(result));
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *obj;
10116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10117 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10118 return SWIG_Py_Void();
10119 }
10120
10121 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122 return SWIG_Python_InitShadowInstance(args);
10123 }
10124
10125 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10126 PyObject *resultobj = 0;
10127 int arg1 = (int) -1 ;
10128 int arg2 = (int) -1 ;
10129 wxGridCellCoords *result = 0 ;
10130 int val1 ;
10131 int ecode1 = 0 ;
10132 int val2 ;
10133 int ecode2 = 0 ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char * kwnames[] = {
10137 (char *) "r",(char *) "c", NULL
10138 };
10139
10140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10141 if (obj0) {
10142 ecode1 = SWIG_AsVal_int(obj0, &val1);
10143 if (!SWIG_IsOK(ecode1)) {
10144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10145 }
10146 arg1 = static_cast< int >(val1);
10147 }
10148 if (obj1) {
10149 ecode2 = SWIG_AsVal_int(obj1, &val2);
10150 if (!SWIG_IsOK(ecode2)) {
10151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10152 }
10153 arg2 = static_cast< int >(val2);
10154 }
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10169 PyObject *resultobj = 0;
10170 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 PyObject *swig_obj[1] ;
10174
10175 if (!args) SWIG_fail;
10176 swig_obj[0] = args;
10177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10180 }
10181 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 delete arg1;
10185
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 resultobj = SWIG_Py_Void();
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10197 PyObject *resultobj = 0;
10198 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10199 int result;
10200 void *argp1 = 0 ;
10201 int res1 = 0 ;
10202 PyObject *swig_obj[1] ;
10203
10204 if (!args) SWIG_fail;
10205 swig_obj[0] = args;
10206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10207 if (!SWIG_IsOK(res1)) {
10208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10209 }
10210 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 resultobj = SWIG_From_int(static_cast< int >(result));
10218 return resultobj;
10219 fail:
10220 return NULL;
10221 }
10222
10223
10224 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10225 PyObject *resultobj = 0;
10226 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10227 int arg2 ;
10228 void *argp1 = 0 ;
10229 int res1 = 0 ;
10230 int val2 ;
10231 int ecode2 = 0 ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 char * kwnames[] = {
10235 (char *) "self",(char *) "n", NULL
10236 };
10237
10238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10240 if (!SWIG_IsOK(res1)) {
10241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10242 }
10243 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10244 ecode2 = SWIG_AsVal_int(obj1, &val2);
10245 if (!SWIG_IsOK(ecode2)) {
10246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10247 }
10248 arg2 = static_cast< int >(val2);
10249 {
10250 PyThreadState* __tstate = wxPyBeginAllowThreads();
10251 (arg1)->SetRow(arg2);
10252 wxPyEndAllowThreads(__tstate);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 resultobj = SWIG_Py_Void();
10256 return resultobj;
10257 fail:
10258 return NULL;
10259 }
10260
10261
10262 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10263 PyObject *resultobj = 0;
10264 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10265 int result;
10266 void *argp1 = 0 ;
10267 int res1 = 0 ;
10268 PyObject *swig_obj[1] ;
10269
10270 if (!args) SWIG_fail;
10271 swig_obj[0] = args;
10272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10273 if (!SWIG_IsOK(res1)) {
10274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10275 }
10276 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 resultobj = SWIG_From_int(static_cast< int >(result));
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj = 0;
10292 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10293 int arg2 ;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 int val2 ;
10297 int ecode2 = 0 ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 char * kwnames[] = {
10301 (char *) "self",(char *) "n", NULL
10302 };
10303
10304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10308 }
10309 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10310 ecode2 = SWIG_AsVal_int(obj1, &val2);
10311 if (!SWIG_IsOK(ecode2)) {
10312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10313 }
10314 arg2 = static_cast< int >(val2);
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 (arg1)->SetCol(arg2);
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 resultobj = SWIG_Py_Void();
10322 return resultobj;
10323 fail:
10324 return NULL;
10325 }
10326
10327
10328 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10329 PyObject *resultobj = 0;
10330 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10331 int arg2 ;
10332 int arg3 ;
10333 void *argp1 = 0 ;
10334 int res1 = 0 ;
10335 int val2 ;
10336 int ecode2 = 0 ;
10337 int val3 ;
10338 int ecode3 = 0 ;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 PyObject * obj2 = 0 ;
10342 char * kwnames[] = {
10343 (char *) "self",(char *) "row",(char *) "col", NULL
10344 };
10345
10346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10348 if (!SWIG_IsOK(res1)) {
10349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10350 }
10351 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10352 ecode2 = SWIG_AsVal_int(obj1, &val2);
10353 if (!SWIG_IsOK(ecode2)) {
10354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10355 }
10356 arg2 = static_cast< int >(val2);
10357 ecode3 = SWIG_AsVal_int(obj2, &val3);
10358 if (!SWIG_IsOK(ecode3)) {
10359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10360 }
10361 arg3 = static_cast< int >(val3);
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 (arg1)->Set(arg2,arg3);
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 resultobj = SWIG_Py_Void();
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj = 0;
10377 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10378 PyObject *arg2 = (PyObject *) 0 ;
10379 bool result;
10380 void *argp1 = 0 ;
10381 int res1 = 0 ;
10382 PyObject * obj0 = 0 ;
10383 PyObject * obj1 = 0 ;
10384 char * kwnames[] = {
10385 (char *) "self",(char *) "other", NULL
10386 };
10387
10388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10390 if (!SWIG_IsOK(res1)) {
10391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10392 }
10393 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10394 arg2 = obj1;
10395 {
10396 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 {
10400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10401 }
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10409 PyObject *resultobj = 0;
10410 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10411 PyObject *arg2 = (PyObject *) 0 ;
10412 bool result;
10413 void *argp1 = 0 ;
10414 int res1 = 0 ;
10415 PyObject * obj0 = 0 ;
10416 PyObject * obj1 = 0 ;
10417 char * kwnames[] = {
10418 (char *) "self",(char *) "other", NULL
10419 };
10420
10421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10423 if (!SWIG_IsOK(res1)) {
10424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10425 }
10426 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10427 arg2 = obj1;
10428 {
10429 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10434 }
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10442 PyObject *resultobj = 0;
10443 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10444 PyObject *result = 0 ;
10445 void *argp1 = 0 ;
10446 int res1 = 0 ;
10447 PyObject *swig_obj[1] ;
10448
10449 if (!args) SWIG_fail;
10450 swig_obj[0] = args;
10451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10452 if (!SWIG_IsOK(res1)) {
10453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10454 }
10455 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10456 {
10457 PyThreadState* __tstate = wxPyBeginAllowThreads();
10458 result = (PyObject *)wxGridCellCoords_Get(arg1);
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 resultobj = result;
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *obj;
10471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10472 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10473 return SWIG_Py_Void();
10474 }
10475
10476 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10477 return SWIG_Python_InitShadowInstance(args);
10478 }
10479
10480 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10481 PyObject *resultobj = 0;
10482 wxWindow *arg1 = (wxWindow *) 0 ;
10483 int arg2 = (int) -1 ;
10484 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10485 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10486 wxSize const &arg4_defvalue = wxDefaultSize ;
10487 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10488 long arg5 = (long) wxWANTS_CHARS ;
10489 wxString const &arg6_defvalue = wxPyGridNameStr ;
10490 wxString *arg6 = (wxString *) &arg6_defvalue ;
10491 wxGrid *result = 0 ;
10492 void *argp1 = 0 ;
10493 int res1 = 0 ;
10494 int val2 ;
10495 int ecode2 = 0 ;
10496 wxPoint temp3 ;
10497 wxSize temp4 ;
10498 long val5 ;
10499 int ecode5 = 0 ;
10500 bool temp6 = false ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503 PyObject * obj2 = 0 ;
10504 PyObject * obj3 = 0 ;
10505 PyObject * obj4 = 0 ;
10506 PyObject * obj5 = 0 ;
10507 char * kwnames[] = {
10508 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10509 };
10510
10511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10515 }
10516 arg1 = reinterpret_cast< wxWindow * >(argp1);
10517 if (obj1) {
10518 ecode2 = SWIG_AsVal_int(obj1, &val2);
10519 if (!SWIG_IsOK(ecode2)) {
10520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10521 }
10522 arg2 = static_cast< int >(val2);
10523 }
10524 if (obj2) {
10525 {
10526 arg3 = &temp3;
10527 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10528 }
10529 }
10530 if (obj3) {
10531 {
10532 arg4 = &temp4;
10533 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10534 }
10535 }
10536 if (obj4) {
10537 ecode5 = SWIG_AsVal_long(obj4, &val5);
10538 if (!SWIG_IsOK(ecode5)) {
10539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10540 }
10541 arg5 = static_cast< long >(val5);
10542 }
10543 if (obj5) {
10544 {
10545 arg6 = wxString_in_helper(obj5);
10546 if (arg6 == NULL) SWIG_fail;
10547 temp6 = true;
10548 }
10549 }
10550 {
10551 if (!wxPyCheckForApp()) SWIG_fail;
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10558 {
10559 if (temp6)
10560 delete arg6;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (temp6)
10566 delete arg6;
10567 }
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxGrid *result = 0 ;
10575
10576 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10577 {
10578 if (!wxPyCheckForApp()) SWIG_fail;
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (wxGrid *)new wxGrid();
10581 wxPyEndAllowThreads(__tstate);
10582 if (PyErr_Occurred()) SWIG_fail;
10583 }
10584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10585 return resultobj;
10586 fail:
10587 return NULL;
10588 }
10589
10590
10591 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj = 0;
10593 wxGrid *arg1 = (wxGrid *) 0 ;
10594 wxWindow *arg2 = (wxWindow *) 0 ;
10595 int arg3 = (int) -1 ;
10596 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10597 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10598 wxSize const &arg5_defvalue = wxDefaultSize ;
10599 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10600 long arg6 = (long) wxWANTS_CHARS ;
10601 wxString const &arg7_defvalue = wxPyGridNameStr ;
10602 wxString *arg7 = (wxString *) &arg7_defvalue ;
10603 bool result;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 void *argp2 = 0 ;
10607 int res2 = 0 ;
10608 int val3 ;
10609 int ecode3 = 0 ;
10610 wxPoint temp4 ;
10611 wxSize temp5 ;
10612 long val6 ;
10613 int ecode6 = 0 ;
10614 bool temp7 = false ;
10615 PyObject * obj0 = 0 ;
10616 PyObject * obj1 = 0 ;
10617 PyObject * obj2 = 0 ;
10618 PyObject * obj3 = 0 ;
10619 PyObject * obj4 = 0 ;
10620 PyObject * obj5 = 0 ;
10621 PyObject * obj6 = 0 ;
10622 char * kwnames[] = {
10623 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10624 };
10625
10626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10628 if (!SWIG_IsOK(res1)) {
10629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10630 }
10631 arg1 = reinterpret_cast< wxGrid * >(argp1);
10632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10633 if (!SWIG_IsOK(res2)) {
10634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10635 }
10636 arg2 = reinterpret_cast< wxWindow * >(argp2);
10637 if (obj2) {
10638 ecode3 = SWIG_AsVal_int(obj2, &val3);
10639 if (!SWIG_IsOK(ecode3)) {
10640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10641 }
10642 arg3 = static_cast< int >(val3);
10643 }
10644 if (obj3) {
10645 {
10646 arg4 = &temp4;
10647 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10648 }
10649 }
10650 if (obj4) {
10651 {
10652 arg5 = &temp5;
10653 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10654 }
10655 }
10656 if (obj5) {
10657 ecode6 = SWIG_AsVal_long(obj5, &val6);
10658 if (!SWIG_IsOK(ecode6)) {
10659 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10660 }
10661 arg6 = static_cast< long >(val6);
10662 }
10663 if (obj6) {
10664 {
10665 arg7 = wxString_in_helper(obj6);
10666 if (arg7 == NULL) SWIG_fail;
10667 temp7 = true;
10668 }
10669 }
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 {
10677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10678 }
10679 {
10680 if (temp7)
10681 delete arg7;
10682 }
10683 return resultobj;
10684 fail:
10685 {
10686 if (temp7)
10687 delete arg7;
10688 }
10689 return NULL;
10690 }
10691
10692
10693 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj = 0;
10695 wxGrid *arg1 = (wxGrid *) 0 ;
10696 int arg2 ;
10697 int arg3 ;
10698 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10699 bool result;
10700 void *argp1 = 0 ;
10701 int res1 = 0 ;
10702 int val2 ;
10703 int ecode2 = 0 ;
10704 int val3 ;
10705 int ecode3 = 0 ;
10706 int val4 ;
10707 int ecode4 = 0 ;
10708 PyObject * obj0 = 0 ;
10709 PyObject * obj1 = 0 ;
10710 PyObject * obj2 = 0 ;
10711 PyObject * obj3 = 0 ;
10712 char * kwnames[] = {
10713 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10714 };
10715
10716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10718 if (!SWIG_IsOK(res1)) {
10719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10720 }
10721 arg1 = reinterpret_cast< wxGrid * >(argp1);
10722 ecode2 = SWIG_AsVal_int(obj1, &val2);
10723 if (!SWIG_IsOK(ecode2)) {
10724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10725 }
10726 arg2 = static_cast< int >(val2);
10727 ecode3 = SWIG_AsVal_int(obj2, &val3);
10728 if (!SWIG_IsOK(ecode3)) {
10729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10730 }
10731 arg3 = static_cast< int >(val3);
10732 if (obj3) {
10733 ecode4 = SWIG_AsVal_int(obj3, &val4);
10734 if (!SWIG_IsOK(ecode4)) {
10735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10736 }
10737 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10738 }
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 {
10746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10747 }
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj = 0;
10756 wxGrid *arg1 = (wxGrid *) 0 ;
10757 WXGRIDSELECTIONMODES arg2 ;
10758 void *argp1 = 0 ;
10759 int res1 = 0 ;
10760 int val2 ;
10761 int ecode2 = 0 ;
10762 PyObject * obj0 = 0 ;
10763 PyObject * obj1 = 0 ;
10764 char * kwnames[] = {
10765 (char *) "self",(char *) "selmode", NULL
10766 };
10767
10768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10770 if (!SWIG_IsOK(res1)) {
10771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10772 }
10773 arg1 = reinterpret_cast< wxGrid * >(argp1);
10774 ecode2 = SWIG_AsVal_int(obj1, &val2);
10775 if (!SWIG_IsOK(ecode2)) {
10776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10777 }
10778 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10779 {
10780 PyThreadState* __tstate = wxPyBeginAllowThreads();
10781 (arg1)->SetSelectionMode(arg2);
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_Py_Void();
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10793 PyObject *resultobj = 0;
10794 wxGrid *arg1 = (wxGrid *) 0 ;
10795 WXGRIDSELECTIONMODES result;
10796 void *argp1 = 0 ;
10797 int res1 = 0 ;
10798 PyObject *swig_obj[1] ;
10799
10800 if (!args) SWIG_fail;
10801 swig_obj[0] = args;
10802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10803 if (!SWIG_IsOK(res1)) {
10804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10805 }
10806 arg1 = reinterpret_cast< wxGrid * >(argp1);
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10810 wxPyEndAllowThreads(__tstate);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_From_int(static_cast< int >(result));
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10821 PyObject *resultobj = 0;
10822 wxGrid *arg1 = (wxGrid *) 0 ;
10823 int result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 PyObject *swig_obj[1] ;
10827
10828 if (!args) SWIG_fail;
10829 swig_obj[0] = args;
10830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10831 if (!SWIG_IsOK(res1)) {
10832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10833 }
10834 arg1 = reinterpret_cast< wxGrid * >(argp1);
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 result = (int)(arg1)->GetNumberRows();
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_From_int(static_cast< int >(result));
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10849 PyObject *resultobj = 0;
10850 wxGrid *arg1 = (wxGrid *) 0 ;
10851 int result;
10852 void *argp1 = 0 ;
10853 int res1 = 0 ;
10854 PyObject *swig_obj[1] ;
10855
10856 if (!args) SWIG_fail;
10857 swig_obj[0] = args;
10858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10859 if (!SWIG_IsOK(res1)) {
10860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10861 }
10862 arg1 = reinterpret_cast< wxGrid * >(argp1);
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (int)(arg1)->GetNumberCols();
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_From_int(static_cast< int >(result));
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj = 0;
10878 wxGrid *arg1 = (wxGrid *) 0 ;
10879 wxGridTableMessage *arg2 = 0 ;
10880 bool result;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 void *argp2 = 0 ;
10884 int res2 = 0 ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 char * kwnames[] = {
10888 (char *) "self",(char *)"arg2", NULL
10889 };
10890
10891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10893 if (!SWIG_IsOK(res1)) {
10894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10895 }
10896 arg1 = reinterpret_cast< wxGrid * >(argp1);
10897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10898 if (!SWIG_IsOK(res2)) {
10899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10900 }
10901 if (!argp2) {
10902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10903 }
10904 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10905 {
10906 PyThreadState* __tstate = wxPyBeginAllowThreads();
10907 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10908 wxPyEndAllowThreads(__tstate);
10909 if (PyErr_Occurred()) SWIG_fail;
10910 }
10911 {
10912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10913 }
10914 return resultobj;
10915 fail:
10916 return NULL;
10917 }
10918
10919
10920 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10921 PyObject *resultobj = 0;
10922 wxGrid *arg1 = (wxGrid *) 0 ;
10923 wxGridTableBase *result = 0 ;
10924 void *argp1 = 0 ;
10925 int res1 = 0 ;
10926 PyObject *swig_obj[1] ;
10927
10928 if (!args) SWIG_fail;
10929 swig_obj[0] = args;
10930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10931 if (!SWIG_IsOK(res1)) {
10932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10933 }
10934 arg1 = reinterpret_cast< wxGrid * >(argp1);
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 {
10942 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10943 }
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxGrid *arg1 = (wxGrid *) 0 ;
10953 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10954 bool arg3 = (bool) false ;
10955 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10956 bool result;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 int res2 = 0 ;
10960 bool val3 ;
10961 int ecode3 = 0 ;
10962 int val4 ;
10963 int ecode4 = 0 ;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 PyObject * obj2 = 0 ;
10967 PyObject * obj3 = 0 ;
10968 char * kwnames[] = {
10969 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10970 };
10971
10972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10974 if (!SWIG_IsOK(res1)) {
10975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10976 }
10977 arg1 = reinterpret_cast< wxGrid * >(argp1);
10978 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10979 if (!SWIG_IsOK(res2)) {
10980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10981 }
10982 if (obj2) {
10983 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10984 if (!SWIG_IsOK(ecode3)) {
10985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10986 }
10987 arg3 = static_cast< bool >(val3);
10988 }
10989 if (obj3) {
10990 ecode4 = SWIG_AsVal_int(obj3, &val4);
10991 if (!SWIG_IsOK(ecode4)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10993 }
10994 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11004 }
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11012 PyObject *resultobj = 0;
11013 wxGrid *arg1 = (wxGrid *) 0 ;
11014 void *argp1 = 0 ;
11015 int res1 = 0 ;
11016 PyObject *swig_obj[1] ;
11017
11018 if (!args) SWIG_fail;
11019 swig_obj[0] = args;
11020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11021 if (!SWIG_IsOK(res1)) {
11022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11023 }
11024 arg1 = reinterpret_cast< wxGrid * >(argp1);
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 (arg1)->ClearGrid();
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 resultobj = SWIG_Py_Void();
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj = 0;
11040 wxGrid *arg1 = (wxGrid *) 0 ;
11041 int arg2 = (int) 0 ;
11042 int arg3 = (int) 1 ;
11043 bool arg4 = (bool) true ;
11044 bool result;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 int val2 ;
11048 int ecode2 = 0 ;
11049 int val3 ;
11050 int ecode3 = 0 ;
11051 bool val4 ;
11052 int ecode4 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 PyObject * obj2 = 0 ;
11056 PyObject * obj3 = 0 ;
11057 char * kwnames[] = {
11058 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11059 };
11060
11061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11065 }
11066 arg1 = reinterpret_cast< wxGrid * >(argp1);
11067 if (obj1) {
11068 ecode2 = SWIG_AsVal_int(obj1, &val2);
11069 if (!SWIG_IsOK(ecode2)) {
11070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11071 }
11072 arg2 = static_cast< int >(val2);
11073 }
11074 if (obj2) {
11075 ecode3 = SWIG_AsVal_int(obj2, &val3);
11076 if (!SWIG_IsOK(ecode3)) {
11077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11078 }
11079 arg3 = static_cast< int >(val3);
11080 }
11081 if (obj3) {
11082 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11083 if (!SWIG_IsOK(ecode4)) {
11084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11085 }
11086 arg4 = static_cast< bool >(val4);
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11104 PyObject *resultobj = 0;
11105 wxGrid *arg1 = (wxGrid *) 0 ;
11106 int arg2 = (int) 1 ;
11107 bool arg3 = (bool) true ;
11108 bool result;
11109 void *argp1 = 0 ;
11110 int res1 = 0 ;
11111 int val2 ;
11112 int ecode2 = 0 ;
11113 bool val3 ;
11114 int ecode3 = 0 ;
11115 PyObject * obj0 = 0 ;
11116 PyObject * obj1 = 0 ;
11117 PyObject * obj2 = 0 ;
11118 char * kwnames[] = {
11119 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11120 };
11121
11122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11124 if (!SWIG_IsOK(res1)) {
11125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11126 }
11127 arg1 = reinterpret_cast< wxGrid * >(argp1);
11128 if (obj1) {
11129 ecode2 = SWIG_AsVal_int(obj1, &val2);
11130 if (!SWIG_IsOK(ecode2)) {
11131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11132 }
11133 arg2 = static_cast< int >(val2);
11134 }
11135 if (obj2) {
11136 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11137 if (!SWIG_IsOK(ecode3)) {
11138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11139 }
11140 arg3 = static_cast< bool >(val3);
11141 }
11142 {
11143 PyThreadState* __tstate = wxPyBeginAllowThreads();
11144 result = (bool)(arg1)->AppendRows(arg2,arg3);
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 {
11149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11150 }
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = 0;
11159 wxGrid *arg1 = (wxGrid *) 0 ;
11160 int arg2 = (int) 0 ;
11161 int arg3 = (int) 1 ;
11162 bool arg4 = (bool) true ;
11163 bool result;
11164 void *argp1 = 0 ;
11165 int res1 = 0 ;
11166 int val2 ;
11167 int ecode2 = 0 ;
11168 int val3 ;
11169 int ecode3 = 0 ;
11170 bool val4 ;
11171 int ecode4 = 0 ;
11172 PyObject * obj0 = 0 ;
11173 PyObject * obj1 = 0 ;
11174 PyObject * obj2 = 0 ;
11175 PyObject * obj3 = 0 ;
11176 char * kwnames[] = {
11177 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11178 };
11179
11180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11182 if (!SWIG_IsOK(res1)) {
11183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11184 }
11185 arg1 = reinterpret_cast< wxGrid * >(argp1);
11186 if (obj1) {
11187 ecode2 = SWIG_AsVal_int(obj1, &val2);
11188 if (!SWIG_IsOK(ecode2)) {
11189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11190 }
11191 arg2 = static_cast< int >(val2);
11192 }
11193 if (obj2) {
11194 ecode3 = SWIG_AsVal_int(obj2, &val3);
11195 if (!SWIG_IsOK(ecode3)) {
11196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11197 }
11198 arg3 = static_cast< int >(val3);
11199 }
11200 if (obj3) {
11201 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11202 if (!SWIG_IsOK(ecode4)) {
11203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11204 }
11205 arg4 = static_cast< bool >(val4);
11206 }
11207 {
11208 PyThreadState* __tstate = wxPyBeginAllowThreads();
11209 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 {
11214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11215 }
11216 return resultobj;
11217 fail:
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11223 PyObject *resultobj = 0;
11224 wxGrid *arg1 = (wxGrid *) 0 ;
11225 int arg2 = (int) 0 ;
11226 int arg3 = (int) 1 ;
11227 bool arg4 = (bool) true ;
11228 bool result;
11229 void *argp1 = 0 ;
11230 int res1 = 0 ;
11231 int val2 ;
11232 int ecode2 = 0 ;
11233 int val3 ;
11234 int ecode3 = 0 ;
11235 bool val4 ;
11236 int ecode4 = 0 ;
11237 PyObject * obj0 = 0 ;
11238 PyObject * obj1 = 0 ;
11239 PyObject * obj2 = 0 ;
11240 PyObject * obj3 = 0 ;
11241 char * kwnames[] = {
11242 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11243 };
11244
11245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11247 if (!SWIG_IsOK(res1)) {
11248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11249 }
11250 arg1 = reinterpret_cast< wxGrid * >(argp1);
11251 if (obj1) {
11252 ecode2 = SWIG_AsVal_int(obj1, &val2);
11253 if (!SWIG_IsOK(ecode2)) {
11254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11255 }
11256 arg2 = static_cast< int >(val2);
11257 }
11258 if (obj2) {
11259 ecode3 = SWIG_AsVal_int(obj2, &val3);
11260 if (!SWIG_IsOK(ecode3)) {
11261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11262 }
11263 arg3 = static_cast< int >(val3);
11264 }
11265 if (obj3) {
11266 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11267 if (!SWIG_IsOK(ecode4)) {
11268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11269 }
11270 arg4 = static_cast< bool >(val4);
11271 }
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11280 }
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj = 0;
11289 wxGrid *arg1 = (wxGrid *) 0 ;
11290 int arg2 = (int) 1 ;
11291 bool arg3 = (bool) true ;
11292 bool result;
11293 void *argp1 = 0 ;
11294 int res1 = 0 ;
11295 int val2 ;
11296 int ecode2 = 0 ;
11297 bool val3 ;
11298 int ecode3 = 0 ;
11299 PyObject * obj0 = 0 ;
11300 PyObject * obj1 = 0 ;
11301 PyObject * obj2 = 0 ;
11302 char * kwnames[] = {
11303 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11304 };
11305
11306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11308 if (!SWIG_IsOK(res1)) {
11309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11310 }
11311 arg1 = reinterpret_cast< wxGrid * >(argp1);
11312 if (obj1) {
11313 ecode2 = SWIG_AsVal_int(obj1, &val2);
11314 if (!SWIG_IsOK(ecode2)) {
11315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11316 }
11317 arg2 = static_cast< int >(val2);
11318 }
11319 if (obj2) {
11320 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11321 if (!SWIG_IsOK(ecode3)) {
11322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11323 }
11324 arg3 = static_cast< bool >(val3);
11325 }
11326 {
11327 PyThreadState* __tstate = wxPyBeginAllowThreads();
11328 result = (bool)(arg1)->AppendCols(arg2,arg3);
11329 wxPyEndAllowThreads(__tstate);
11330 if (PyErr_Occurred()) SWIG_fail;
11331 }
11332 {
11333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11334 }
11335 return resultobj;
11336 fail:
11337 return NULL;
11338 }
11339
11340
11341 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj = 0;
11343 wxGrid *arg1 = (wxGrid *) 0 ;
11344 int arg2 = (int) 0 ;
11345 int arg3 = (int) 1 ;
11346 bool arg4 = (bool) true ;
11347 bool result;
11348 void *argp1 = 0 ;
11349 int res1 = 0 ;
11350 int val2 ;
11351 int ecode2 = 0 ;
11352 int val3 ;
11353 int ecode3 = 0 ;
11354 bool val4 ;
11355 int ecode4 = 0 ;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 PyObject * obj2 = 0 ;
11359 PyObject * obj3 = 0 ;
11360 char * kwnames[] = {
11361 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11362 };
11363
11364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11366 if (!SWIG_IsOK(res1)) {
11367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11368 }
11369 arg1 = reinterpret_cast< wxGrid * >(argp1);
11370 if (obj1) {
11371 ecode2 = SWIG_AsVal_int(obj1, &val2);
11372 if (!SWIG_IsOK(ecode2)) {
11373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11374 }
11375 arg2 = static_cast< int >(val2);
11376 }
11377 if (obj2) {
11378 ecode3 = SWIG_AsVal_int(obj2, &val3);
11379 if (!SWIG_IsOK(ecode3)) {
11380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11381 }
11382 arg3 = static_cast< int >(val3);
11383 }
11384 if (obj3) {
11385 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11386 if (!SWIG_IsOK(ecode4)) {
11387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11388 }
11389 arg4 = static_cast< bool >(val4);
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 {
11398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11399 }
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11407 PyObject *resultobj = 0;
11408 wxGrid *arg1 = (wxGrid *) 0 ;
11409 wxDC *arg2 = 0 ;
11410 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11411 void *argp1 = 0 ;
11412 int res1 = 0 ;
11413 void *argp2 = 0 ;
11414 int res2 = 0 ;
11415 void *argp3 = 0 ;
11416 int res3 = 0 ;
11417 PyObject * obj0 = 0 ;
11418 PyObject * obj1 = 0 ;
11419 PyObject * obj2 = 0 ;
11420 char * kwnames[] = {
11421 (char *) "self",(char *) "dc",(char *) "attr", NULL
11422 };
11423
11424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11426 if (!SWIG_IsOK(res1)) {
11427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11428 }
11429 arg1 = reinterpret_cast< wxGrid * >(argp1);
11430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11431 if (!SWIG_IsOK(res2)) {
11432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11433 }
11434 if (!argp2) {
11435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11436 }
11437 arg2 = reinterpret_cast< wxDC * >(argp2);
11438 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11439 if (!SWIG_IsOK(res3)) {
11440 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11441 }
11442 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11443 {
11444 PyThreadState* __tstate = wxPyBeginAllowThreads();
11445 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11446 wxPyEndAllowThreads(__tstate);
11447 if (PyErr_Occurred()) SWIG_fail;
11448 }
11449 resultobj = SWIG_Py_Void();
11450 return resultobj;
11451 fail:
11452 return NULL;
11453 }
11454
11455
11456 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11457 PyObject *resultobj = 0;
11458 wxGrid *arg1 = (wxGrid *) 0 ;
11459 wxDC *arg2 = 0 ;
11460 wxString *arg3 = 0 ;
11461 wxRect *arg4 = 0 ;
11462 int arg5 = (int) wxLEFT ;
11463 int arg6 = (int) wxTOP ;
11464 int arg7 = (int) wxHORIZONTAL ;
11465 void *argp1 = 0 ;
11466 int res1 = 0 ;
11467 void *argp2 = 0 ;
11468 int res2 = 0 ;
11469 bool temp3 = false ;
11470 wxRect temp4 ;
11471 int val5 ;
11472 int ecode5 = 0 ;
11473 int val6 ;
11474 int ecode6 = 0 ;
11475 int val7 ;
11476 int ecode7 = 0 ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 PyObject * obj2 = 0 ;
11480 PyObject * obj3 = 0 ;
11481 PyObject * obj4 = 0 ;
11482 PyObject * obj5 = 0 ;
11483 PyObject * obj6 = 0 ;
11484 char * kwnames[] = {
11485 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11486 };
11487
11488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11492 }
11493 arg1 = reinterpret_cast< wxGrid * >(argp1);
11494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11495 if (!SWIG_IsOK(res2)) {
11496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11497 }
11498 if (!argp2) {
11499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11500 }
11501 arg2 = reinterpret_cast< wxDC * >(argp2);
11502 {
11503 arg3 = wxString_in_helper(obj2);
11504 if (arg3 == NULL) SWIG_fail;
11505 temp3 = true;
11506 }
11507 {
11508 arg4 = &temp4;
11509 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11510 }
11511 if (obj4) {
11512 ecode5 = SWIG_AsVal_int(obj4, &val5);
11513 if (!SWIG_IsOK(ecode5)) {
11514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11515 }
11516 arg5 = static_cast< int >(val5);
11517 }
11518 if (obj5) {
11519 ecode6 = SWIG_AsVal_int(obj5, &val6);
11520 if (!SWIG_IsOK(ecode6)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11522 }
11523 arg6 = static_cast< int >(val6);
11524 }
11525 if (obj6) {
11526 ecode7 = SWIG_AsVal_int(obj6, &val7);
11527 if (!SWIG_IsOK(ecode7)) {
11528 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11529 }
11530 arg7 = static_cast< int >(val7);
11531 }
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_Py_Void();
11539 {
11540 if (temp3)
11541 delete arg3;
11542 }
11543 return resultobj;
11544 fail:
11545 {
11546 if (temp3)
11547 delete arg3;
11548 }
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj = 0;
11555 wxGrid *arg1 = (wxGrid *) 0 ;
11556 wxDC *arg2 = 0 ;
11557 wxArrayString *arg3 = 0 ;
11558 long *arg4 = (long *) 0 ;
11559 long *arg5 = (long *) 0 ;
11560 void *argp1 = 0 ;
11561 int res1 = 0 ;
11562 void *argp2 = 0 ;
11563 int res2 = 0 ;
11564 bool temp3 = false ;
11565 long temp4 ;
11566 int res4 = SWIG_TMPOBJ ;
11567 long temp5 ;
11568 int res5 = SWIG_TMPOBJ ;
11569 PyObject * obj0 = 0 ;
11570 PyObject * obj1 = 0 ;
11571 PyObject * obj2 = 0 ;
11572 char * kwnames[] = {
11573 (char *) "self",(char *) "dc",(char *) "lines", NULL
11574 };
11575
11576 arg4 = &temp4;
11577 arg5 = &temp5;
11578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11580 if (!SWIG_IsOK(res1)) {
11581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11582 }
11583 arg1 = reinterpret_cast< wxGrid * >(argp1);
11584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11585 if (!SWIG_IsOK(res2)) {
11586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11587 }
11588 if (!argp2) {
11589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11590 }
11591 arg2 = reinterpret_cast< wxDC * >(argp2);
11592 {
11593 if (! PySequence_Check(obj2)) {
11594 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11595 SWIG_fail;
11596 }
11597 arg3 = new wxArrayString;
11598 temp3 = true;
11599 int i, len=PySequence_Length(obj2);
11600 for (i=0; i<len; i++) {
11601 PyObject* item = PySequence_GetItem(obj2, i);
11602 wxString* s = wxString_in_helper(item);
11603 if (PyErr_Occurred()) SWIG_fail;
11604 arg3->Add(*s);
11605 delete s;
11606 Py_DECREF(item);
11607 }
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 resultobj = SWIG_Py_Void();
11616 if (SWIG_IsTmpObj(res4)) {
11617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11618 } else {
11619 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11621 }
11622 if (SWIG_IsTmpObj(res5)) {
11623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11624 } else {
11625 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11627 }
11628 {
11629 if (temp3) delete arg3;
11630 }
11631 return resultobj;
11632 fail:
11633 {
11634 if (temp3) delete arg3;
11635 }
11636 return NULL;
11637 }
11638
11639
11640 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11641 PyObject *resultobj = 0;
11642 wxGrid *arg1 = (wxGrid *) 0 ;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 PyObject *swig_obj[1] ;
11646
11647 if (!args) SWIG_fail;
11648 swig_obj[0] = args;
11649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11652 }
11653 arg1 = reinterpret_cast< wxGrid * >(argp1);
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 (arg1)->BeginBatch();
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 resultobj = SWIG_Py_Void();
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 wxGrid *arg1 = (wxGrid *) 0 ;
11670 void *argp1 = 0 ;
11671 int res1 = 0 ;
11672 PyObject *swig_obj[1] ;
11673
11674 if (!args) SWIG_fail;
11675 swig_obj[0] = args;
11676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11679 }
11680 arg1 = reinterpret_cast< wxGrid * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 (arg1)->EndBatch();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 resultobj = SWIG_Py_Void();
11688 return resultobj;
11689 fail:
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxGrid *arg1 = (wxGrid *) 0 ;
11697 int result;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11707 }
11708 arg1 = reinterpret_cast< wxGrid * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (int)(arg1)->GetBatchCount();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_From_int(static_cast< int >(result));
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxGrid *arg1 = (wxGrid *) 0 ;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11734 }
11735 arg1 = reinterpret_cast< wxGrid * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 (arg1)->ForceRefresh();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11750 PyObject *resultobj = 0;
11751 wxGrid *arg1 = (wxGrid *) 0 ;
11752 bool result;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 PyObject *swig_obj[1] ;
11756
11757 if (!args) SWIG_fail;
11758 swig_obj[0] = args;
11759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11760 if (!SWIG_IsOK(res1)) {
11761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11762 }
11763 arg1 = reinterpret_cast< wxGrid * >(argp1);
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (bool)(arg1)->IsEditable();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 {
11771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11772 }
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11780 PyObject *resultobj = 0;
11781 wxGrid *arg1 = (wxGrid *) 0 ;
11782 bool arg2 ;
11783 void *argp1 = 0 ;
11784 int res1 = 0 ;
11785 bool val2 ;
11786 int ecode2 = 0 ;
11787 PyObject * obj0 = 0 ;
11788 PyObject * obj1 = 0 ;
11789 char * kwnames[] = {
11790 (char *) "self",(char *) "edit", NULL
11791 };
11792
11793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11795 if (!SWIG_IsOK(res1)) {
11796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11797 }
11798 arg1 = reinterpret_cast< wxGrid * >(argp1);
11799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11800 if (!SWIG_IsOK(ecode2)) {
11801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11802 }
11803 arg2 = static_cast< bool >(val2);
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 (arg1)->EnableEditing(arg2);
11807 wxPyEndAllowThreads(__tstate);
11808 if (PyErr_Occurred()) SWIG_fail;
11809 }
11810 resultobj = SWIG_Py_Void();
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj = 0;
11819 wxGrid *arg1 = (wxGrid *) 0 ;
11820 bool arg2 = (bool) true ;
11821 void *argp1 = 0 ;
11822 int res1 = 0 ;
11823 bool val2 ;
11824 int ecode2 = 0 ;
11825 PyObject * obj0 = 0 ;
11826 PyObject * obj1 = 0 ;
11827 char * kwnames[] = {
11828 (char *) "self",(char *) "enable", NULL
11829 };
11830
11831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11835 }
11836 arg1 = reinterpret_cast< wxGrid * >(argp1);
11837 if (obj1) {
11838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11839 if (!SWIG_IsOK(ecode2)) {
11840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11841 }
11842 arg2 = static_cast< bool >(val2);
11843 }
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 (arg1)->EnableCellEditControl(arg2);
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 resultobj = SWIG_Py_Void();
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11858 PyObject *resultobj = 0;
11859 wxGrid *arg1 = (wxGrid *) 0 ;
11860 void *argp1 = 0 ;
11861 int res1 = 0 ;
11862 PyObject *swig_obj[1] ;
11863
11864 if (!args) SWIG_fail;
11865 swig_obj[0] = args;
11866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11867 if (!SWIG_IsOK(res1)) {
11868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11869 }
11870 arg1 = reinterpret_cast< wxGrid * >(argp1);
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 (arg1)->DisableCellEditControl();
11874 wxPyEndAllowThreads(__tstate);
11875 if (PyErr_Occurred()) SWIG_fail;
11876 }
11877 resultobj = SWIG_Py_Void();
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885 PyObject *resultobj = 0;
11886 wxGrid *arg1 = (wxGrid *) 0 ;
11887 bool result;
11888 void *argp1 = 0 ;
11889 int res1 = 0 ;
11890 PyObject *swig_obj[1] ;
11891
11892 if (!args) SWIG_fail;
11893 swig_obj[0] = args;
11894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11895 if (!SWIG_IsOK(res1)) {
11896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11897 }
11898 arg1 = reinterpret_cast< wxGrid * >(argp1);
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11902 wxPyEndAllowThreads(__tstate);
11903 if (PyErr_Occurred()) SWIG_fail;
11904 }
11905 {
11906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11907 }
11908 return resultobj;
11909 fail:
11910 return NULL;
11911 }
11912
11913
11914 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11915 PyObject *resultobj = 0;
11916 wxGrid *arg1 = (wxGrid *) 0 ;
11917 bool result;
11918 void *argp1 = 0 ;
11919 int res1 = 0 ;
11920 PyObject *swig_obj[1] ;
11921
11922 if (!args) SWIG_fail;
11923 swig_obj[0] = args;
11924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11925 if (!SWIG_IsOK(res1)) {
11926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11927 }
11928 arg1 = reinterpret_cast< wxGrid * >(argp1);
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 {
11936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11937 }
11938 return resultobj;
11939 fail:
11940 return NULL;
11941 }
11942
11943
11944 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11945 PyObject *resultobj = 0;
11946 wxGrid *arg1 = (wxGrid *) 0 ;
11947 bool result;
11948 void *argp1 = 0 ;
11949 int res1 = 0 ;
11950 PyObject *swig_obj[1] ;
11951
11952 if (!args) SWIG_fail;
11953 swig_obj[0] = args;
11954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11955 if (!SWIG_IsOK(res1)) {
11956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11957 }
11958 arg1 = reinterpret_cast< wxGrid * >(argp1);
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11967 }
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11975 PyObject *resultobj = 0;
11976 wxGrid *arg1 = (wxGrid *) 0 ;
11977 bool result;
11978 void *argp1 = 0 ;
11979 int res1 = 0 ;
11980 PyObject *swig_obj[1] ;
11981
11982 if (!args) SWIG_fail;
11983 swig_obj[0] = args;
11984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11987 }
11988 arg1 = reinterpret_cast< wxGrid * >(argp1);
11989 {
11990 PyThreadState* __tstate = wxPyBeginAllowThreads();
11991 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11992 wxPyEndAllowThreads(__tstate);
11993 if (PyErr_Occurred()) SWIG_fail;
11994 }
11995 {
11996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11997 }
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 PyObject *resultobj = 0;
12006 wxGrid *arg1 = (wxGrid *) 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 PyObject *swig_obj[1] ;
12010
12011 if (!args) SWIG_fail;
12012 swig_obj[0] = args;
12013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12016 }
12017 arg1 = reinterpret_cast< wxGrid * >(argp1);
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 (arg1)->ShowCellEditControl();
12021 wxPyEndAllowThreads(__tstate);
12022 if (PyErr_Occurred()) SWIG_fail;
12023 }
12024 resultobj = SWIG_Py_Void();
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 PyObject *resultobj = 0;
12033 wxGrid *arg1 = (wxGrid *) 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 PyObject *swig_obj[1] ;
12037
12038 if (!args) SWIG_fail;
12039 swig_obj[0] = args;
12040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12041 if (!SWIG_IsOK(res1)) {
12042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12043 }
12044 arg1 = reinterpret_cast< wxGrid * >(argp1);
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 (arg1)->HideCellEditControl();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 resultobj = SWIG_Py_Void();
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12059 PyObject *resultobj = 0;
12060 wxGrid *arg1 = (wxGrid *) 0 ;
12061 void *argp1 = 0 ;
12062 int res1 = 0 ;
12063 PyObject *swig_obj[1] ;
12064
12065 if (!args) SWIG_fail;
12066 swig_obj[0] = args;
12067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12068 if (!SWIG_IsOK(res1)) {
12069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12070 }
12071 arg1 = reinterpret_cast< wxGrid * >(argp1);
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 (arg1)->SaveEditControlValue();
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_Py_Void();
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj = 0;
12087 wxGrid *arg1 = (wxGrid *) 0 ;
12088 int arg2 ;
12089 int arg3 ;
12090 wxGridCellCoords result;
12091 void *argp1 = 0 ;
12092 int res1 = 0 ;
12093 int val2 ;
12094 int ecode2 = 0 ;
12095 int val3 ;
12096 int ecode3 = 0 ;
12097 PyObject * obj0 = 0 ;
12098 PyObject * obj1 = 0 ;
12099 PyObject * obj2 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "self",(char *) "x",(char *) "y", NULL
12102 };
12103
12104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12106 if (!SWIG_IsOK(res1)) {
12107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12108 }
12109 arg1 = reinterpret_cast< wxGrid * >(argp1);
12110 ecode2 = SWIG_AsVal_int(obj1, &val2);
12111 if (!SWIG_IsOK(ecode2)) {
12112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12113 }
12114 arg2 = static_cast< int >(val2);
12115 ecode3 = SWIG_AsVal_int(obj2, &val3);
12116 if (!SWIG_IsOK(ecode3)) {
12117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12118 }
12119 arg3 = static_cast< int >(val3);
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = wxGrid_XYToCell(arg1,arg2,arg3);
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxGrid *arg1 = (wxGrid *) 0 ;
12136 int arg2 ;
12137 int result;
12138 void *argp1 = 0 ;
12139 int res1 = 0 ;
12140 int val2 ;
12141 int ecode2 = 0 ;
12142 PyObject * obj0 = 0 ;
12143 PyObject * obj1 = 0 ;
12144 char * kwnames[] = {
12145 (char *) "self",(char *) "y", NULL
12146 };
12147
12148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12150 if (!SWIG_IsOK(res1)) {
12151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12152 }
12153 arg1 = reinterpret_cast< wxGrid * >(argp1);
12154 ecode2 = SWIG_AsVal_int(obj1, &val2);
12155 if (!SWIG_IsOK(ecode2)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12157 }
12158 arg2 = static_cast< int >(val2);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (int)(arg1)->YToRow(arg2);
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_From_int(static_cast< int >(result));
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12173 PyObject *resultobj = 0;
12174 wxGrid *arg1 = (wxGrid *) 0 ;
12175 int arg2 ;
12176 bool arg3 = (bool) false ;
12177 int result;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 int val2 ;
12181 int ecode2 = 0 ;
12182 bool val3 ;
12183 int ecode3 = 0 ;
12184 PyObject * obj0 = 0 ;
12185 PyObject * obj1 = 0 ;
12186 PyObject * obj2 = 0 ;
12187 char * kwnames[] = {
12188 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12189 };
12190
12191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12193 if (!SWIG_IsOK(res1)) {
12194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12195 }
12196 arg1 = reinterpret_cast< wxGrid * >(argp1);
12197 ecode2 = SWIG_AsVal_int(obj1, &val2);
12198 if (!SWIG_IsOK(ecode2)) {
12199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12200 }
12201 arg2 = static_cast< int >(val2);
12202 if (obj2) {
12203 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12204 if (!SWIG_IsOK(ecode3)) {
12205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12206 }
12207 arg3 = static_cast< bool >(val3);
12208 }
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 result = (int)(arg1)->XToCol(arg2,arg3);
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 resultobj = SWIG_From_int(static_cast< int >(result));
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12223 PyObject *resultobj = 0;
12224 wxGrid *arg1 = (wxGrid *) 0 ;
12225 int arg2 ;
12226 int result;
12227 void *argp1 = 0 ;
12228 int res1 = 0 ;
12229 int val2 ;
12230 int ecode2 = 0 ;
12231 PyObject * obj0 = 0 ;
12232 PyObject * obj1 = 0 ;
12233 char * kwnames[] = {
12234 (char *) "self",(char *) "y", NULL
12235 };
12236
12237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12239 if (!SWIG_IsOK(res1)) {
12240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12241 }
12242 arg1 = reinterpret_cast< wxGrid * >(argp1);
12243 ecode2 = SWIG_AsVal_int(obj1, &val2);
12244 if (!SWIG_IsOK(ecode2)) {
12245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12246 }
12247 arg2 = static_cast< int >(val2);
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (int)(arg1)->YToEdgeOfRow(arg2);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 resultobj = SWIG_From_int(static_cast< int >(result));
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12262 PyObject *resultobj = 0;
12263 wxGrid *arg1 = (wxGrid *) 0 ;
12264 int arg2 ;
12265 int result;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 int val2 ;
12269 int ecode2 = 0 ;
12270 PyObject * obj0 = 0 ;
12271 PyObject * obj1 = 0 ;
12272 char * kwnames[] = {
12273 (char *) "self",(char *) "x", NULL
12274 };
12275
12276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12278 if (!SWIG_IsOK(res1)) {
12279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12280 }
12281 arg1 = reinterpret_cast< wxGrid * >(argp1);
12282 ecode2 = SWIG_AsVal_int(obj1, &val2);
12283 if (!SWIG_IsOK(ecode2)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12285 }
12286 arg2 = static_cast< int >(val2);
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (int)(arg1)->XToEdgeOfCol(arg2);
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_From_int(static_cast< int >(result));
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = 0;
12302 wxGrid *arg1 = (wxGrid *) 0 ;
12303 int arg2 ;
12304 int arg3 ;
12305 wxRect result;
12306 void *argp1 = 0 ;
12307 int res1 = 0 ;
12308 int val2 ;
12309 int ecode2 = 0 ;
12310 int val3 ;
12311 int ecode3 = 0 ;
12312 PyObject * obj0 = 0 ;
12313 PyObject * obj1 = 0 ;
12314 PyObject * obj2 = 0 ;
12315 char * kwnames[] = {
12316 (char *) "self",(char *) "row",(char *) "col", NULL
12317 };
12318
12319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12321 if (!SWIG_IsOK(res1)) {
12322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12323 }
12324 arg1 = reinterpret_cast< wxGrid * >(argp1);
12325 ecode2 = SWIG_AsVal_int(obj1, &val2);
12326 if (!SWIG_IsOK(ecode2)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12328 }
12329 arg2 = static_cast< int >(val2);
12330 ecode3 = SWIG_AsVal_int(obj2, &val3);
12331 if (!SWIG_IsOK(ecode3)) {
12332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12333 }
12334 arg3 = static_cast< int >(val3);
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (arg1)->CellToRect(arg2,arg3);
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12349 PyObject *resultobj = 0;
12350 wxGrid *arg1 = (wxGrid *) 0 ;
12351 int result;
12352 void *argp1 = 0 ;
12353 int res1 = 0 ;
12354 PyObject *swig_obj[1] ;
12355
12356 if (!args) SWIG_fail;
12357 swig_obj[0] = args;
12358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12359 if (!SWIG_IsOK(res1)) {
12360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12361 }
12362 arg1 = reinterpret_cast< wxGrid * >(argp1);
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (int)(arg1)->GetGridCursorRow();
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_From_int(static_cast< int >(result));
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12377 PyObject *resultobj = 0;
12378 wxGrid *arg1 = (wxGrid *) 0 ;
12379 int result;
12380 void *argp1 = 0 ;
12381 int res1 = 0 ;
12382 PyObject *swig_obj[1] ;
12383
12384 if (!args) SWIG_fail;
12385 swig_obj[0] = args;
12386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12387 if (!SWIG_IsOK(res1)) {
12388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12389 }
12390 arg1 = reinterpret_cast< wxGrid * >(argp1);
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (int)(arg1)->GetGridCursorCol();
12394 wxPyEndAllowThreads(__tstate);
12395 if (PyErr_Occurred()) SWIG_fail;
12396 }
12397 resultobj = SWIG_From_int(static_cast< int >(result));
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj = 0;
12406 wxGrid *arg1 = (wxGrid *) 0 ;
12407 int arg2 ;
12408 int arg3 ;
12409 bool arg4 = (bool) true ;
12410 bool result;
12411 void *argp1 = 0 ;
12412 int res1 = 0 ;
12413 int val2 ;
12414 int ecode2 = 0 ;
12415 int val3 ;
12416 int ecode3 = 0 ;
12417 bool val4 ;
12418 int ecode4 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 PyObject * obj3 = 0 ;
12423 char * kwnames[] = {
12424 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12425 };
12426
12427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12431 }
12432 arg1 = reinterpret_cast< wxGrid * >(argp1);
12433 ecode2 = SWIG_AsVal_int(obj1, &val2);
12434 if (!SWIG_IsOK(ecode2)) {
12435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12436 }
12437 arg2 = static_cast< int >(val2);
12438 ecode3 = SWIG_AsVal_int(obj2, &val3);
12439 if (!SWIG_IsOK(ecode3)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12441 }
12442 arg3 = static_cast< int >(val3);
12443 if (obj3) {
12444 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12445 if (!SWIG_IsOK(ecode4)) {
12446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12447 }
12448 arg4 = static_cast< bool >(val4);
12449 }
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12453 wxPyEndAllowThreads(__tstate);
12454 if (PyErr_Occurred()) SWIG_fail;
12455 }
12456 {
12457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12458 }
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12466 PyObject *resultobj = 0;
12467 wxGrid *arg1 = (wxGrid *) 0 ;
12468 int arg2 ;
12469 int arg3 ;
12470 void *argp1 = 0 ;
12471 int res1 = 0 ;
12472 int val2 ;
12473 int ecode2 = 0 ;
12474 int val3 ;
12475 int ecode3 = 0 ;
12476 PyObject * obj0 = 0 ;
12477 PyObject * obj1 = 0 ;
12478 PyObject * obj2 = 0 ;
12479 char * kwnames[] = {
12480 (char *) "self",(char *) "row",(char *) "col", NULL
12481 };
12482
12483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12487 }
12488 arg1 = reinterpret_cast< wxGrid * >(argp1);
12489 ecode2 = SWIG_AsVal_int(obj1, &val2);
12490 if (!SWIG_IsOK(ecode2)) {
12491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12492 }
12493 arg2 = static_cast< int >(val2);
12494 ecode3 = SWIG_AsVal_int(obj2, &val3);
12495 if (!SWIG_IsOK(ecode3)) {
12496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12497 }
12498 arg3 = static_cast< int >(val3);
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 (arg1)->MakeCellVisible(arg2,arg3);
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 resultobj = SWIG_Py_Void();
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj = 0;
12514 wxGrid *arg1 = (wxGrid *) 0 ;
12515 int arg2 ;
12516 int arg3 ;
12517 void *argp1 = 0 ;
12518 int res1 = 0 ;
12519 int val2 ;
12520 int ecode2 = 0 ;
12521 int val3 ;
12522 int ecode3 = 0 ;
12523 PyObject * obj0 = 0 ;
12524 PyObject * obj1 = 0 ;
12525 PyObject * obj2 = 0 ;
12526 char * kwnames[] = {
12527 (char *) "self",(char *) "row",(char *) "col", NULL
12528 };
12529
12530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12532 if (!SWIG_IsOK(res1)) {
12533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12534 }
12535 arg1 = reinterpret_cast< wxGrid * >(argp1);
12536 ecode2 = SWIG_AsVal_int(obj1, &val2);
12537 if (!SWIG_IsOK(ecode2)) {
12538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12539 }
12540 arg2 = static_cast< int >(val2);
12541 ecode3 = SWIG_AsVal_int(obj2, &val3);
12542 if (!SWIG_IsOK(ecode3)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12544 }
12545 arg3 = static_cast< int >(val3);
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 (arg1)->SetGridCursor(arg2,arg3);
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 resultobj = SWIG_Py_Void();
12553 return resultobj;
12554 fail:
12555 return NULL;
12556 }
12557
12558
12559 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12560 PyObject *resultobj = 0;
12561 wxGrid *arg1 = (wxGrid *) 0 ;
12562 bool arg2 ;
12563 bool result;
12564 void *argp1 = 0 ;
12565 int res1 = 0 ;
12566 bool val2 ;
12567 int ecode2 = 0 ;
12568 PyObject * obj0 = 0 ;
12569 PyObject * obj1 = 0 ;
12570 char * kwnames[] = {
12571 (char *) "self",(char *) "expandSelection", NULL
12572 };
12573
12574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12576 if (!SWIG_IsOK(res1)) {
12577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12578 }
12579 arg1 = reinterpret_cast< wxGrid * >(argp1);
12580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12581 if (!SWIG_IsOK(ecode2)) {
12582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12583 }
12584 arg2 = static_cast< bool >(val2);
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (bool)(arg1)->MoveCursorUp(arg2);
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12593 }
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj = 0;
12602 wxGrid *arg1 = (wxGrid *) 0 ;
12603 bool arg2 ;
12604 bool result;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 bool val2 ;
12608 int ecode2 = 0 ;
12609 PyObject * obj0 = 0 ;
12610 PyObject * obj1 = 0 ;
12611 char * kwnames[] = {
12612 (char *) "self",(char *) "expandSelection", NULL
12613 };
12614
12615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12617 if (!SWIG_IsOK(res1)) {
12618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12619 }
12620 arg1 = reinterpret_cast< wxGrid * >(argp1);
12621 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12622 if (!SWIG_IsOK(ecode2)) {
12623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12624 }
12625 arg2 = static_cast< bool >(val2);
12626 {
12627 PyThreadState* __tstate = wxPyBeginAllowThreads();
12628 result = (bool)(arg1)->MoveCursorDown(arg2);
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 {
12633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12634 }
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj = 0;
12643 wxGrid *arg1 = (wxGrid *) 0 ;
12644 bool arg2 ;
12645 bool result;
12646 void *argp1 = 0 ;
12647 int res1 = 0 ;
12648 bool val2 ;
12649 int ecode2 = 0 ;
12650 PyObject * obj0 = 0 ;
12651 PyObject * obj1 = 0 ;
12652 char * kwnames[] = {
12653 (char *) "self",(char *) "expandSelection", NULL
12654 };
12655
12656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12658 if (!SWIG_IsOK(res1)) {
12659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12660 }
12661 arg1 = reinterpret_cast< wxGrid * >(argp1);
12662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12663 if (!SWIG_IsOK(ecode2)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12665 }
12666 arg2 = static_cast< bool >(val2);
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 result = (bool)(arg1)->MoveCursorLeft(arg2);
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 {
12674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12675 }
12676 return resultobj;
12677 fail:
12678 return NULL;
12679 }
12680
12681
12682 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12683 PyObject *resultobj = 0;
12684 wxGrid *arg1 = (wxGrid *) 0 ;
12685 bool arg2 ;
12686 bool result;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 bool val2 ;
12690 int ecode2 = 0 ;
12691 PyObject * obj0 = 0 ;
12692 PyObject * obj1 = 0 ;
12693 char * kwnames[] = {
12694 (char *) "self",(char *) "expandSelection", NULL
12695 };
12696
12697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12699 if (!SWIG_IsOK(res1)) {
12700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12701 }
12702 arg1 = reinterpret_cast< wxGrid * >(argp1);
12703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12704 if (!SWIG_IsOK(ecode2)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12706 }
12707 arg2 = static_cast< bool >(val2);
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (bool)(arg1)->MoveCursorRight(arg2);
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxGrid *arg1 = (wxGrid *) 0 ;
12726 bool result;
12727 void *argp1 = 0 ;
12728 int res1 = 0 ;
12729 PyObject *swig_obj[1] ;
12730
12731 if (!args) SWIG_fail;
12732 swig_obj[0] = args;
12733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12736 }
12737 arg1 = reinterpret_cast< wxGrid * >(argp1);
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (bool)(arg1)->MovePageDown();
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 {
12745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12746 }
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12754 PyObject *resultobj = 0;
12755 wxGrid *arg1 = (wxGrid *) 0 ;
12756 bool result;
12757 void *argp1 = 0 ;
12758 int res1 = 0 ;
12759 PyObject *swig_obj[1] ;
12760
12761 if (!args) SWIG_fail;
12762 swig_obj[0] = args;
12763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12764 if (!SWIG_IsOK(res1)) {
12765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12766 }
12767 arg1 = reinterpret_cast< wxGrid * >(argp1);
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (bool)(arg1)->MovePageUp();
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 {
12775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12776 }
12777 return resultobj;
12778 fail:
12779 return NULL;
12780 }
12781
12782
12783 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12784 PyObject *resultobj = 0;
12785 wxGrid *arg1 = (wxGrid *) 0 ;
12786 bool arg2 ;
12787 bool result;
12788 void *argp1 = 0 ;
12789 int res1 = 0 ;
12790 bool val2 ;
12791 int ecode2 = 0 ;
12792 PyObject * obj0 = 0 ;
12793 PyObject * obj1 = 0 ;
12794 char * kwnames[] = {
12795 (char *) "self",(char *) "expandSelection", NULL
12796 };
12797
12798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12800 if (!SWIG_IsOK(res1)) {
12801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12802 }
12803 arg1 = reinterpret_cast< wxGrid * >(argp1);
12804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12805 if (!SWIG_IsOK(ecode2)) {
12806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12807 }
12808 arg2 = static_cast< bool >(val2);
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 {
12816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12817 }
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj = 0;
12826 wxGrid *arg1 = (wxGrid *) 0 ;
12827 bool arg2 ;
12828 bool result;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 bool val2 ;
12832 int ecode2 = 0 ;
12833 PyObject * obj0 = 0 ;
12834 PyObject * obj1 = 0 ;
12835 char * kwnames[] = {
12836 (char *) "self",(char *) "expandSelection", NULL
12837 };
12838
12839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12841 if (!SWIG_IsOK(res1)) {
12842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12843 }
12844 arg1 = reinterpret_cast< wxGrid * >(argp1);
12845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12846 if (!SWIG_IsOK(ecode2)) {
12847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12848 }
12849 arg2 = static_cast< bool >(val2);
12850 {
12851 PyThreadState* __tstate = wxPyBeginAllowThreads();
12852 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12853 wxPyEndAllowThreads(__tstate);
12854 if (PyErr_Occurred()) SWIG_fail;
12855 }
12856 {
12857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12858 }
12859 return resultobj;
12860 fail:
12861 return NULL;
12862 }
12863
12864
12865 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12866 PyObject *resultobj = 0;
12867 wxGrid *arg1 = (wxGrid *) 0 ;
12868 bool arg2 ;
12869 bool result;
12870 void *argp1 = 0 ;
12871 int res1 = 0 ;
12872 bool val2 ;
12873 int ecode2 = 0 ;
12874 PyObject * obj0 = 0 ;
12875 PyObject * obj1 = 0 ;
12876 char * kwnames[] = {
12877 (char *) "self",(char *) "expandSelection", NULL
12878 };
12879
12880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12882 if (!SWIG_IsOK(res1)) {
12883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12884 }
12885 arg1 = reinterpret_cast< wxGrid * >(argp1);
12886 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12887 if (!SWIG_IsOK(ecode2)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12889 }
12890 arg2 = static_cast< bool >(val2);
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 {
12898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12899 }
12900 return resultobj;
12901 fail:
12902 return NULL;
12903 }
12904
12905
12906 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12907 PyObject *resultobj = 0;
12908 wxGrid *arg1 = (wxGrid *) 0 ;
12909 bool arg2 ;
12910 bool result;
12911 void *argp1 = 0 ;
12912 int res1 = 0 ;
12913 bool val2 ;
12914 int ecode2 = 0 ;
12915 PyObject * obj0 = 0 ;
12916 PyObject * obj1 = 0 ;
12917 char * kwnames[] = {
12918 (char *) "self",(char *) "expandSelection", NULL
12919 };
12920
12921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12923 if (!SWIG_IsOK(res1)) {
12924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12925 }
12926 arg1 = reinterpret_cast< wxGrid * >(argp1);
12927 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12928 if (!SWIG_IsOK(ecode2)) {
12929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12930 }
12931 arg2 = static_cast< bool >(val2);
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 {
12939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12940 }
12941 return resultobj;
12942 fail:
12943 return NULL;
12944 }
12945
12946
12947 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948 PyObject *resultobj = 0;
12949 wxGrid *arg1 = (wxGrid *) 0 ;
12950 int result;
12951 void *argp1 = 0 ;
12952 int res1 = 0 ;
12953 PyObject *swig_obj[1] ;
12954
12955 if (!args) SWIG_fail;
12956 swig_obj[0] = args;
12957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12958 if (!SWIG_IsOK(res1)) {
12959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12960 }
12961 arg1 = reinterpret_cast< wxGrid * >(argp1);
12962 {
12963 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 result = (int)(arg1)->GetDefaultRowLabelSize();
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 resultobj = SWIG_From_int(static_cast< int >(result));
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxGrid *arg1 = (wxGrid *) 0 ;
12978 int result;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 PyObject *swig_obj[1] ;
12982
12983 if (!args) SWIG_fail;
12984 swig_obj[0] = args;
12985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12986 if (!SWIG_IsOK(res1)) {
12987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12988 }
12989 arg1 = reinterpret_cast< wxGrid * >(argp1);
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (int)(arg1)->GetRowLabelSize();
12993 wxPyEndAllowThreads(__tstate);
12994 if (PyErr_Occurred()) SWIG_fail;
12995 }
12996 resultobj = SWIG_From_int(static_cast< int >(result));
12997 return resultobj;
12998 fail:
12999 return NULL;
13000 }
13001
13002
13003 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 PyObject *resultobj = 0;
13005 wxGrid *arg1 = (wxGrid *) 0 ;
13006 int result;
13007 void *argp1 = 0 ;
13008 int res1 = 0 ;
13009 PyObject *swig_obj[1] ;
13010
13011 if (!args) SWIG_fail;
13012 swig_obj[0] = args;
13013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13014 if (!SWIG_IsOK(res1)) {
13015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13016 }
13017 arg1 = reinterpret_cast< wxGrid * >(argp1);
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (int)(arg1)->GetDefaultColLabelSize();
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 resultobj = SWIG_From_int(static_cast< int >(result));
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13032 PyObject *resultobj = 0;
13033 wxGrid *arg1 = (wxGrid *) 0 ;
13034 int result;
13035 void *argp1 = 0 ;
13036 int res1 = 0 ;
13037 PyObject *swig_obj[1] ;
13038
13039 if (!args) SWIG_fail;
13040 swig_obj[0] = args;
13041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13044 }
13045 arg1 = reinterpret_cast< wxGrid * >(argp1);
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (int)(arg1)->GetColLabelSize();
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 resultobj = SWIG_From_int(static_cast< int >(result));
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13060 PyObject *resultobj = 0;
13061 wxGrid *arg1 = (wxGrid *) 0 ;
13062 wxColour result;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 PyObject *swig_obj[1] ;
13066
13067 if (!args) SWIG_fail;
13068 swig_obj[0] = args;
13069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13070 if (!SWIG_IsOK(res1)) {
13071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13072 }
13073 arg1 = reinterpret_cast< wxGrid * >(argp1);
13074 {
13075 PyThreadState* __tstate = wxPyBeginAllowThreads();
13076 result = (arg1)->GetLabelBackgroundColour();
13077 wxPyEndAllowThreads(__tstate);
13078 if (PyErr_Occurred()) SWIG_fail;
13079 }
13080 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13088 PyObject *resultobj = 0;
13089 wxGrid *arg1 = (wxGrid *) 0 ;
13090 wxColour result;
13091 void *argp1 = 0 ;
13092 int res1 = 0 ;
13093 PyObject *swig_obj[1] ;
13094
13095 if (!args) SWIG_fail;
13096 swig_obj[0] = args;
13097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13098 if (!SWIG_IsOK(res1)) {
13099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13100 }
13101 arg1 = reinterpret_cast< wxGrid * >(argp1);
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (arg1)->GetLabelTextColour();
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13116 PyObject *resultobj = 0;
13117 wxGrid *arg1 = (wxGrid *) 0 ;
13118 wxFont result;
13119 void *argp1 = 0 ;
13120 int res1 = 0 ;
13121 PyObject *swig_obj[1] ;
13122
13123 if (!args) SWIG_fail;
13124 swig_obj[0] = args;
13125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13126 if (!SWIG_IsOK(res1)) {
13127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13128 }
13129 arg1 = reinterpret_cast< wxGrid * >(argp1);
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 result = (arg1)->GetLabelFont();
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13144 PyObject *resultobj = 0;
13145 wxGrid *arg1 = (wxGrid *) 0 ;
13146 int *arg2 = (int *) 0 ;
13147 int *arg3 = (int *) 0 ;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 int temp2 ;
13151 int res2 = SWIG_TMPOBJ ;
13152 int temp3 ;
13153 int res3 = SWIG_TMPOBJ ;
13154 PyObject *swig_obj[1] ;
13155
13156 arg2 = &temp2;
13157 arg3 = &temp3;
13158 if (!args) SWIG_fail;
13159 swig_obj[0] = args;
13160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13161 if (!SWIG_IsOK(res1)) {
13162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13163 }
13164 arg1 = reinterpret_cast< wxGrid * >(argp1);
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 (arg1)->GetRowLabelAlignment(arg2,arg3);
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 resultobj = SWIG_Py_Void();
13172 if (SWIG_IsTmpObj(res2)) {
13173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13174 } else {
13175 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13177 }
13178 if (SWIG_IsTmpObj(res3)) {
13179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13180 } else {
13181 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13183 }
13184 return resultobj;
13185 fail:
13186 return NULL;
13187 }
13188
13189
13190 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13191 PyObject *resultobj = 0;
13192 wxGrid *arg1 = (wxGrid *) 0 ;
13193 int *arg2 = (int *) 0 ;
13194 int *arg3 = (int *) 0 ;
13195 void *argp1 = 0 ;
13196 int res1 = 0 ;
13197 int temp2 ;
13198 int res2 = SWIG_TMPOBJ ;
13199 int temp3 ;
13200 int res3 = SWIG_TMPOBJ ;
13201 PyObject *swig_obj[1] ;
13202
13203 arg2 = &temp2;
13204 arg3 = &temp3;
13205 if (!args) SWIG_fail;
13206 swig_obj[0] = args;
13207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13208 if (!SWIG_IsOK(res1)) {
13209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13210 }
13211 arg1 = reinterpret_cast< wxGrid * >(argp1);
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 (arg1)->GetColLabelAlignment(arg2,arg3);
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 resultobj = SWIG_Py_Void();
13219 if (SWIG_IsTmpObj(res2)) {
13220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13221 } else {
13222 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13224 }
13225 if (SWIG_IsTmpObj(res3)) {
13226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13227 } else {
13228 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13230 }
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13238 PyObject *resultobj = 0;
13239 wxGrid *arg1 = (wxGrid *) 0 ;
13240 int result;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 PyObject *swig_obj[1] ;
13244
13245 if (!args) SWIG_fail;
13246 swig_obj[0] = args;
13247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13248 if (!SWIG_IsOK(res1)) {
13249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13250 }
13251 arg1 = reinterpret_cast< wxGrid * >(argp1);
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 result = (int)(arg1)->GetColLabelTextOrientation();
13255 wxPyEndAllowThreads(__tstate);
13256 if (PyErr_Occurred()) SWIG_fail;
13257 }
13258 resultobj = SWIG_From_int(static_cast< int >(result));
13259 return resultobj;
13260 fail:
13261 return NULL;
13262 }
13263
13264
13265 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj = 0;
13267 wxGrid *arg1 = (wxGrid *) 0 ;
13268 int arg2 ;
13269 wxString result;
13270 void *argp1 = 0 ;
13271 int res1 = 0 ;
13272 int val2 ;
13273 int ecode2 = 0 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "self",(char *) "row", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13282 if (!SWIG_IsOK(res1)) {
13283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13284 }
13285 arg1 = reinterpret_cast< wxGrid * >(argp1);
13286 ecode2 = SWIG_AsVal_int(obj1, &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13289 }
13290 arg2 = static_cast< int >(val2);
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 result = (arg1)->GetRowLabelValue(arg2);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 {
13298 #if wxUSE_UNICODE
13299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13300 #else
13301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13302 #endif
13303 }
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxGrid *arg1 = (wxGrid *) 0 ;
13313 int arg2 ;
13314 wxString result;
13315 void *argp1 = 0 ;
13316 int res1 = 0 ;
13317 int val2 ;
13318 int ecode2 = 0 ;
13319 PyObject * obj0 = 0 ;
13320 PyObject * obj1 = 0 ;
13321 char * kwnames[] = {
13322 (char *) "self",(char *) "col", NULL
13323 };
13324
13325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13327 if (!SWIG_IsOK(res1)) {
13328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13329 }
13330 arg1 = reinterpret_cast< wxGrid * >(argp1);
13331 ecode2 = SWIG_AsVal_int(obj1, &val2);
13332 if (!SWIG_IsOK(ecode2)) {
13333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13334 }
13335 arg2 = static_cast< int >(val2);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (arg1)->GetColLabelValue(arg2);
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 {
13343 #if wxUSE_UNICODE
13344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13345 #else
13346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13347 #endif
13348 }
13349 return resultobj;
13350 fail:
13351 return NULL;
13352 }
13353
13354
13355 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13356 PyObject *resultobj = 0;
13357 wxGrid *arg1 = (wxGrid *) 0 ;
13358 wxColour result;
13359 void *argp1 = 0 ;
13360 int res1 = 0 ;
13361 PyObject *swig_obj[1] ;
13362
13363 if (!args) SWIG_fail;
13364 swig_obj[0] = args;
13365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13366 if (!SWIG_IsOK(res1)) {
13367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13368 }
13369 arg1 = reinterpret_cast< wxGrid * >(argp1);
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 result = (arg1)->GetGridLineColour();
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 PyObject *resultobj = 0;
13385 wxGrid *arg1 = (wxGrid *) 0 ;
13386 wxPen result;
13387 void *argp1 = 0 ;
13388 int res1 = 0 ;
13389 PyObject *swig_obj[1] ;
13390
13391 if (!args) SWIG_fail;
13392 swig_obj[0] = args;
13393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13394 if (!SWIG_IsOK(res1)) {
13395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13396 }
13397 arg1 = reinterpret_cast< wxGrid * >(argp1);
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 result = (arg1)->GetDefaultGridLinePen();
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj = 0;
13413 wxGrid *arg1 = (wxGrid *) 0 ;
13414 int arg2 ;
13415 wxPen result;
13416 void *argp1 = 0 ;
13417 int res1 = 0 ;
13418 int val2 ;
13419 int ecode2 = 0 ;
13420 PyObject * obj0 = 0 ;
13421 PyObject * obj1 = 0 ;
13422 char * kwnames[] = {
13423 (char *) "self",(char *) "row", NULL
13424 };
13425
13426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13428 if (!SWIG_IsOK(res1)) {
13429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13430 }
13431 arg1 = reinterpret_cast< wxGrid * >(argp1);
13432 ecode2 = SWIG_AsVal_int(obj1, &val2);
13433 if (!SWIG_IsOK(ecode2)) {
13434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13435 }
13436 arg2 = static_cast< int >(val2);
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (arg1)->GetRowGridLinePen(arg2);
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = 0;
13452 wxGrid *arg1 = (wxGrid *) 0 ;
13453 int arg2 ;
13454 wxPen result;
13455 void *argp1 = 0 ;
13456 int res1 = 0 ;
13457 int val2 ;
13458 int ecode2 = 0 ;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char * kwnames[] = {
13462 (char *) "self",(char *) "col", NULL
13463 };
13464
13465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13467 if (!SWIG_IsOK(res1)) {
13468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13469 }
13470 arg1 = reinterpret_cast< wxGrid * >(argp1);
13471 ecode2 = SWIG_AsVal_int(obj1, &val2);
13472 if (!SWIG_IsOK(ecode2)) {
13473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13474 }
13475 arg2 = static_cast< int >(val2);
13476 {
13477 PyThreadState* __tstate = wxPyBeginAllowThreads();
13478 result = (arg1)->GetColGridLinePen(arg2);
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13483 return resultobj;
13484 fail:
13485 return NULL;
13486 }
13487
13488
13489 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13490 PyObject *resultobj = 0;
13491 wxGrid *arg1 = (wxGrid *) 0 ;
13492 wxColour result;
13493 void *argp1 = 0 ;
13494 int res1 = 0 ;
13495 PyObject *swig_obj[1] ;
13496
13497 if (!args) SWIG_fail;
13498 swig_obj[0] = args;
13499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13500 if (!SWIG_IsOK(res1)) {
13501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13502 }
13503 arg1 = reinterpret_cast< wxGrid * >(argp1);
13504 {
13505 PyThreadState* __tstate = wxPyBeginAllowThreads();
13506 result = (arg1)->GetCellHighlightColour();
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13518 PyObject *resultobj = 0;
13519 wxGrid *arg1 = (wxGrid *) 0 ;
13520 int result;
13521 void *argp1 = 0 ;
13522 int res1 = 0 ;
13523 PyObject *swig_obj[1] ;
13524
13525 if (!args) SWIG_fail;
13526 swig_obj[0] = args;
13527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13528 if (!SWIG_IsOK(res1)) {
13529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13530 }
13531 arg1 = reinterpret_cast< wxGrid * >(argp1);
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 result = (int)(arg1)->GetCellHighlightPenWidth();
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_From_int(static_cast< int >(result));
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13546 PyObject *resultobj = 0;
13547 wxGrid *arg1 = (wxGrid *) 0 ;
13548 int result;
13549 void *argp1 = 0 ;
13550 int res1 = 0 ;
13551 PyObject *swig_obj[1] ;
13552
13553 if (!args) SWIG_fail;
13554 swig_obj[0] = args;
13555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13556 if (!SWIG_IsOK(res1)) {
13557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13558 }
13559 arg1 = reinterpret_cast< wxGrid * >(argp1);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = (int)(arg1)->GetCellHighlightROPenWidth();
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_From_int(static_cast< int >(result));
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxGrid *arg1 = (wxGrid *) 0 ;
13576 int arg2 ;
13577 void *argp1 = 0 ;
13578 int res1 = 0 ;
13579 int val2 ;
13580 int ecode2 = 0 ;
13581 PyObject * obj0 = 0 ;
13582 PyObject * obj1 = 0 ;
13583 char * kwnames[] = {
13584 (char *) "self",(char *) "width", NULL
13585 };
13586
13587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13589 if (!SWIG_IsOK(res1)) {
13590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13591 }
13592 arg1 = reinterpret_cast< wxGrid * >(argp1);
13593 ecode2 = SWIG_AsVal_int(obj1, &val2);
13594 if (!SWIG_IsOK(ecode2)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13596 }
13597 arg2 = static_cast< int >(val2);
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 (arg1)->SetRowLabelSize(arg2);
13601 wxPyEndAllowThreads(__tstate);
13602 if (PyErr_Occurred()) SWIG_fail;
13603 }
13604 resultobj = SWIG_Py_Void();
13605 return resultobj;
13606 fail:
13607 return NULL;
13608 }
13609
13610
13611 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj = 0;
13613 wxGrid *arg1 = (wxGrid *) 0 ;
13614 int arg2 ;
13615 void *argp1 = 0 ;
13616 int res1 = 0 ;
13617 int val2 ;
13618 int ecode2 = 0 ;
13619 PyObject * obj0 = 0 ;
13620 PyObject * obj1 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "self",(char *) "height", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13627 if (!SWIG_IsOK(res1)) {
13628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13629 }
13630 arg1 = reinterpret_cast< wxGrid * >(argp1);
13631 ecode2 = SWIG_AsVal_int(obj1, &val2);
13632 if (!SWIG_IsOK(ecode2)) {
13633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13634 }
13635 arg2 = static_cast< int >(val2);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 (arg1)->SetColLabelSize(arg2);
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxGrid *arg1 = (wxGrid *) 0 ;
13652 wxColour *arg2 = 0 ;
13653 void *argp1 = 0 ;
13654 int res1 = 0 ;
13655 wxColour temp2 ;
13656 PyObject * obj0 = 0 ;
13657 PyObject * obj1 = 0 ;
13658 char * kwnames[] = {
13659 (char *) "self",(char *)"arg2", NULL
13660 };
13661
13662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13664 if (!SWIG_IsOK(res1)) {
13665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13666 }
13667 arg1 = reinterpret_cast< wxGrid * >(argp1);
13668 {
13669 arg2 = &temp2;
13670 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 resultobj = SWIG_Py_Void();
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxGrid *arg1 = (wxGrid *) 0 ;
13688 wxColour *arg2 = 0 ;
13689 void *argp1 = 0 ;
13690 int res1 = 0 ;
13691 wxColour temp2 ;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 char * kwnames[] = {
13695 (char *) "self",(char *)"arg2", NULL
13696 };
13697
13698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13700 if (!SWIG_IsOK(res1)) {
13701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13702 }
13703 arg1 = reinterpret_cast< wxGrid * >(argp1);
13704 {
13705 arg2 = &temp2;
13706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13707 }
13708 {
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 resultobj = SWIG_Py_Void();
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = 0;
13723 wxGrid *arg1 = (wxGrid *) 0 ;
13724 wxFont *arg2 = 0 ;
13725 void *argp1 = 0 ;
13726 int res1 = 0 ;
13727 void *argp2 = 0 ;
13728 int res2 = 0 ;
13729 PyObject * obj0 = 0 ;
13730 PyObject * obj1 = 0 ;
13731 char * kwnames[] = {
13732 (char *) "self",(char *)"arg2", NULL
13733 };
13734
13735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13737 if (!SWIG_IsOK(res1)) {
13738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13739 }
13740 arg1 = reinterpret_cast< wxGrid * >(argp1);
13741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13742 if (!SWIG_IsOK(res2)) {
13743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13744 }
13745 if (!argp2) {
13746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13747 }
13748 arg2 = reinterpret_cast< wxFont * >(argp2);
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 (arg1)->SetLabelFont((wxFont const &)*arg2);
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_Py_Void();
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj = 0;
13764 wxGrid *arg1 = (wxGrid *) 0 ;
13765 int arg2 ;
13766 int arg3 ;
13767 void *argp1 = 0 ;
13768 int res1 = 0 ;
13769 int val2 ;
13770 int ecode2 = 0 ;
13771 int val3 ;
13772 int ecode3 = 0 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 char * kwnames[] = {
13777 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13778 };
13779
13780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13782 if (!SWIG_IsOK(res1)) {
13783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13784 }
13785 arg1 = reinterpret_cast< wxGrid * >(argp1);
13786 ecode2 = SWIG_AsVal_int(obj1, &val2);
13787 if (!SWIG_IsOK(ecode2)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13789 }
13790 arg2 = static_cast< int >(val2);
13791 ecode3 = SWIG_AsVal_int(obj2, &val3);
13792 if (!SWIG_IsOK(ecode3)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13794 }
13795 arg3 = static_cast< int >(val3);
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 (arg1)->SetRowLabelAlignment(arg2,arg3);
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_Py_Void();
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj = 0;
13811 wxGrid *arg1 = (wxGrid *) 0 ;
13812 int arg2 ;
13813 int arg3 ;
13814 void *argp1 = 0 ;
13815 int res1 = 0 ;
13816 int val2 ;
13817 int ecode2 = 0 ;
13818 int val3 ;
13819 int ecode3 = 0 ;
13820 PyObject * obj0 = 0 ;
13821 PyObject * obj1 = 0 ;
13822 PyObject * obj2 = 0 ;
13823 char * kwnames[] = {
13824 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13825 };
13826
13827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13829 if (!SWIG_IsOK(res1)) {
13830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13831 }
13832 arg1 = reinterpret_cast< wxGrid * >(argp1);
13833 ecode2 = SWIG_AsVal_int(obj1, &val2);
13834 if (!SWIG_IsOK(ecode2)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13836 }
13837 arg2 = static_cast< int >(val2);
13838 ecode3 = SWIG_AsVal_int(obj2, &val3);
13839 if (!SWIG_IsOK(ecode3)) {
13840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13841 }
13842 arg3 = static_cast< int >(val3);
13843 {
13844 PyThreadState* __tstate = wxPyBeginAllowThreads();
13845 (arg1)->SetColLabelAlignment(arg2,arg3);
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_Py_Void();
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj = 0;
13858 wxGrid *arg1 = (wxGrid *) 0 ;
13859 int arg2 ;
13860 void *argp1 = 0 ;
13861 int res1 = 0 ;
13862 int val2 ;
13863 int ecode2 = 0 ;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 char * kwnames[] = {
13867 (char *) "self",(char *) "textOrientation", NULL
13868 };
13869
13870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13872 if (!SWIG_IsOK(res1)) {
13873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13874 }
13875 arg1 = reinterpret_cast< wxGrid * >(argp1);
13876 ecode2 = SWIG_AsVal_int(obj1, &val2);
13877 if (!SWIG_IsOK(ecode2)) {
13878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13879 }
13880 arg2 = static_cast< int >(val2);
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 (arg1)->SetColLabelTextOrientation(arg2);
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 resultobj = SWIG_Py_Void();
13888 return resultobj;
13889 fail:
13890 return NULL;
13891 }
13892
13893
13894 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13895 PyObject *resultobj = 0;
13896 wxGrid *arg1 = (wxGrid *) 0 ;
13897 int arg2 ;
13898 wxString *arg3 = 0 ;
13899 void *argp1 = 0 ;
13900 int res1 = 0 ;
13901 int val2 ;
13902 int ecode2 = 0 ;
13903 bool temp3 = false ;
13904 PyObject * obj0 = 0 ;
13905 PyObject * obj1 = 0 ;
13906 PyObject * obj2 = 0 ;
13907 char * kwnames[] = {
13908 (char *) "self",(char *) "row",(char *)"arg3", NULL
13909 };
13910
13911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13913 if (!SWIG_IsOK(res1)) {
13914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13915 }
13916 arg1 = reinterpret_cast< wxGrid * >(argp1);
13917 ecode2 = SWIG_AsVal_int(obj1, &val2);
13918 if (!SWIG_IsOK(ecode2)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13920 }
13921 arg2 = static_cast< int >(val2);
13922 {
13923 arg3 = wxString_in_helper(obj2);
13924 if (arg3 == NULL) SWIG_fail;
13925 temp3 = true;
13926 }
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 {
13935 if (temp3)
13936 delete arg3;
13937 }
13938 return resultobj;
13939 fail:
13940 {
13941 if (temp3)
13942 delete arg3;
13943 }
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj = 0;
13950 wxGrid *arg1 = (wxGrid *) 0 ;
13951 int arg2 ;
13952 wxString *arg3 = 0 ;
13953 void *argp1 = 0 ;
13954 int res1 = 0 ;
13955 int val2 ;
13956 int ecode2 = 0 ;
13957 bool temp3 = false ;
13958 PyObject * obj0 = 0 ;
13959 PyObject * obj1 = 0 ;
13960 PyObject * obj2 = 0 ;
13961 char * kwnames[] = {
13962 (char *) "self",(char *) "col",(char *)"arg3", NULL
13963 };
13964
13965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13967 if (!SWIG_IsOK(res1)) {
13968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13969 }
13970 arg1 = reinterpret_cast< wxGrid * >(argp1);
13971 ecode2 = SWIG_AsVal_int(obj1, &val2);
13972 if (!SWIG_IsOK(ecode2)) {
13973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13974 }
13975 arg2 = static_cast< int >(val2);
13976 {
13977 arg3 = wxString_in_helper(obj2);
13978 if (arg3 == NULL) SWIG_fail;
13979 temp3 = true;
13980 }
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 resultobj = SWIG_Py_Void();
13988 {
13989 if (temp3)
13990 delete arg3;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp3)
13996 delete arg3;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj = 0;
14004 wxGrid *arg1 = (wxGrid *) 0 ;
14005 wxColour *arg2 = 0 ;
14006 void *argp1 = 0 ;
14007 int res1 = 0 ;
14008 wxColour temp2 ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "self",(char *)"arg2", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14017 if (!SWIG_IsOK(res1)) {
14018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14019 }
14020 arg1 = reinterpret_cast< wxGrid * >(argp1);
14021 {
14022 arg2 = &temp2;
14023 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 resultobj = SWIG_Py_Void();
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj = 0;
14040 wxGrid *arg1 = (wxGrid *) 0 ;
14041 wxColour *arg2 = 0 ;
14042 void *argp1 = 0 ;
14043 int res1 = 0 ;
14044 wxColour temp2 ;
14045 PyObject * obj0 = 0 ;
14046 PyObject * obj1 = 0 ;
14047 char * kwnames[] = {
14048 (char *) "self",(char *)"arg2", NULL
14049 };
14050
14051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14053 if (!SWIG_IsOK(res1)) {
14054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14055 }
14056 arg1 = reinterpret_cast< wxGrid * >(argp1);
14057 {
14058 arg2 = &temp2;
14059 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14060 }
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_Py_Void();
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxGrid *arg1 = (wxGrid *) 0 ;
14077 int arg2 ;
14078 void *argp1 = 0 ;
14079 int res1 = 0 ;
14080 int val2 ;
14081 int ecode2 = 0 ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 char * kwnames[] = {
14085 (char *) "self",(char *) "width", NULL
14086 };
14087
14088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14092 }
14093 arg1 = reinterpret_cast< wxGrid * >(argp1);
14094 ecode2 = SWIG_AsVal_int(obj1, &val2);
14095 if (!SWIG_IsOK(ecode2)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14097 }
14098 arg2 = static_cast< int >(val2);
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 (arg1)->SetCellHighlightPenWidth(arg2);
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 resultobj = SWIG_Py_Void();
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj = 0;
14114 wxGrid *arg1 = (wxGrid *) 0 ;
14115 int arg2 ;
14116 void *argp1 = 0 ;
14117 int res1 = 0 ;
14118 int val2 ;
14119 int ecode2 = 0 ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 char * kwnames[] = {
14123 (char *) "self",(char *) "width", NULL
14124 };
14125
14126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14128 if (!SWIG_IsOK(res1)) {
14129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14130 }
14131 arg1 = reinterpret_cast< wxGrid * >(argp1);
14132 ecode2 = SWIG_AsVal_int(obj1, &val2);
14133 if (!SWIG_IsOK(ecode2)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14135 }
14136 arg2 = static_cast< int >(val2);
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 (arg1)->SetCellHighlightROPenWidth(arg2);
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 resultobj = SWIG_Py_Void();
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxGrid *arg1 = (wxGrid *) 0 ;
14153 bool arg2 = (bool) true ;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 bool val2 ;
14157 int ecode2 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "self",(char *) "enable", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14168 }
14169 arg1 = reinterpret_cast< wxGrid * >(argp1);
14170 if (obj1) {
14171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14172 if (!SWIG_IsOK(ecode2)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14174 }
14175 arg2 = static_cast< bool >(val2);
14176 }
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 (arg1)->EnableDragRowSize(arg2);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_Py_Void();
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 PyObject *resultobj = 0;
14192 wxGrid *arg1 = (wxGrid *) 0 ;
14193 void *argp1 = 0 ;
14194 int res1 = 0 ;
14195 PyObject *swig_obj[1] ;
14196
14197 if (!args) SWIG_fail;
14198 swig_obj[0] = args;
14199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14200 if (!SWIG_IsOK(res1)) {
14201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14202 }
14203 arg1 = reinterpret_cast< wxGrid * >(argp1);
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 (arg1)->DisableDragRowSize();
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 resultobj = SWIG_Py_Void();
14211 return resultobj;
14212 fail:
14213 return NULL;
14214 }
14215
14216
14217 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14218 PyObject *resultobj = 0;
14219 wxGrid *arg1 = (wxGrid *) 0 ;
14220 bool result;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 PyObject *swig_obj[1] ;
14224
14225 if (!args) SWIG_fail;
14226 swig_obj[0] = args;
14227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14228 if (!SWIG_IsOK(res1)) {
14229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14230 }
14231 arg1 = reinterpret_cast< wxGrid * >(argp1);
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (bool)(arg1)->CanDragRowSize();
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 {
14239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj = 0;
14249 wxGrid *arg1 = (wxGrid *) 0 ;
14250 bool arg2 = (bool) true ;
14251 void *argp1 = 0 ;
14252 int res1 = 0 ;
14253 bool val2 ;
14254 int ecode2 = 0 ;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 char * kwnames[] = {
14258 (char *) "self",(char *) "enable", NULL
14259 };
14260
14261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14263 if (!SWIG_IsOK(res1)) {
14264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14265 }
14266 arg1 = reinterpret_cast< wxGrid * >(argp1);
14267 if (obj1) {
14268 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14269 if (!SWIG_IsOK(ecode2)) {
14270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14271 }
14272 arg2 = static_cast< bool >(val2);
14273 }
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 (arg1)->EnableDragColSize(arg2);
14277 wxPyEndAllowThreads(__tstate);
14278 if (PyErr_Occurred()) SWIG_fail;
14279 }
14280 resultobj = SWIG_Py_Void();
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14288 PyObject *resultobj = 0;
14289 wxGrid *arg1 = (wxGrid *) 0 ;
14290 void *argp1 = 0 ;
14291 int res1 = 0 ;
14292 PyObject *swig_obj[1] ;
14293
14294 if (!args) SWIG_fail;
14295 swig_obj[0] = args;
14296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14297 if (!SWIG_IsOK(res1)) {
14298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14299 }
14300 arg1 = reinterpret_cast< wxGrid * >(argp1);
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 (arg1)->DisableDragColSize();
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_Py_Void();
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14315 PyObject *resultobj = 0;
14316 wxGrid *arg1 = (wxGrid *) 0 ;
14317 bool result;
14318 void *argp1 = 0 ;
14319 int res1 = 0 ;
14320 PyObject *swig_obj[1] ;
14321
14322 if (!args) SWIG_fail;
14323 swig_obj[0] = args;
14324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14325 if (!SWIG_IsOK(res1)) {
14326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14327 }
14328 arg1 = reinterpret_cast< wxGrid * >(argp1);
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 result = (bool)(arg1)->CanDragColSize();
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 {
14336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14337 }
14338 return resultobj;
14339 fail:
14340 return NULL;
14341 }
14342
14343
14344 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14345 PyObject *resultobj = 0;
14346 wxGrid *arg1 = (wxGrid *) 0 ;
14347 bool arg2 = (bool) true ;
14348 void *argp1 = 0 ;
14349 int res1 = 0 ;
14350 bool val2 ;
14351 int ecode2 = 0 ;
14352 PyObject * obj0 = 0 ;
14353 PyObject * obj1 = 0 ;
14354 char * kwnames[] = {
14355 (char *) "self",(char *) "enable", NULL
14356 };
14357
14358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14360 if (!SWIG_IsOK(res1)) {
14361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14362 }
14363 arg1 = reinterpret_cast< wxGrid * >(argp1);
14364 if (obj1) {
14365 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14366 if (!SWIG_IsOK(ecode2)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14368 }
14369 arg2 = static_cast< bool >(val2);
14370 }
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 (arg1)->EnableDragColMove(arg2);
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 resultobj = SWIG_Py_Void();
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14385 PyObject *resultobj = 0;
14386 wxGrid *arg1 = (wxGrid *) 0 ;
14387 void *argp1 = 0 ;
14388 int res1 = 0 ;
14389 PyObject *swig_obj[1] ;
14390
14391 if (!args) SWIG_fail;
14392 swig_obj[0] = args;
14393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14394 if (!SWIG_IsOK(res1)) {
14395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14396 }
14397 arg1 = reinterpret_cast< wxGrid * >(argp1);
14398 {
14399 PyThreadState* __tstate = wxPyBeginAllowThreads();
14400 (arg1)->DisableDragColMove();
14401 wxPyEndAllowThreads(__tstate);
14402 if (PyErr_Occurred()) SWIG_fail;
14403 }
14404 resultobj = SWIG_Py_Void();
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14412 PyObject *resultobj = 0;
14413 wxGrid *arg1 = (wxGrid *) 0 ;
14414 bool result;
14415 void *argp1 = 0 ;
14416 int res1 = 0 ;
14417 PyObject *swig_obj[1] ;
14418
14419 if (!args) SWIG_fail;
14420 swig_obj[0] = args;
14421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14422 if (!SWIG_IsOK(res1)) {
14423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14424 }
14425 arg1 = reinterpret_cast< wxGrid * >(argp1);
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (bool)(arg1)->CanDragColMove();
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14434 }
14435 return resultobj;
14436 fail:
14437 return NULL;
14438 }
14439
14440
14441 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj = 0;
14443 wxGrid *arg1 = (wxGrid *) 0 ;
14444 bool arg2 = (bool) true ;
14445 void *argp1 = 0 ;
14446 int res1 = 0 ;
14447 bool val2 ;
14448 int ecode2 = 0 ;
14449 PyObject * obj0 = 0 ;
14450 PyObject * obj1 = 0 ;
14451 char * kwnames[] = {
14452 (char *) "self",(char *) "enable", NULL
14453 };
14454
14455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14457 if (!SWIG_IsOK(res1)) {
14458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14459 }
14460 arg1 = reinterpret_cast< wxGrid * >(argp1);
14461 if (obj1) {
14462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14463 if (!SWIG_IsOK(ecode2)) {
14464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14465 }
14466 arg2 = static_cast< bool >(val2);
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 (arg1)->EnableDragGridSize(arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_Py_Void();
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14482 PyObject *resultobj = 0;
14483 wxGrid *arg1 = (wxGrid *) 0 ;
14484 void *argp1 = 0 ;
14485 int res1 = 0 ;
14486 PyObject *swig_obj[1] ;
14487
14488 if (!args) SWIG_fail;
14489 swig_obj[0] = args;
14490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14493 }
14494 arg1 = reinterpret_cast< wxGrid * >(argp1);
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 (arg1)->DisableDragGridSize();
14498 wxPyEndAllowThreads(__tstate);
14499 if (PyErr_Occurred()) SWIG_fail;
14500 }
14501 resultobj = SWIG_Py_Void();
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14509 PyObject *resultobj = 0;
14510 wxGrid *arg1 = (wxGrid *) 0 ;
14511 bool result;
14512 void *argp1 = 0 ;
14513 int res1 = 0 ;
14514 PyObject *swig_obj[1] ;
14515
14516 if (!args) SWIG_fail;
14517 swig_obj[0] = args;
14518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14521 }
14522 arg1 = reinterpret_cast< wxGrid * >(argp1);
14523 {
14524 PyThreadState* __tstate = wxPyBeginAllowThreads();
14525 result = (bool)(arg1)->CanDragGridSize();
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 {
14530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14531 }
14532 return resultobj;
14533 fail:
14534 return NULL;
14535 }
14536
14537
14538 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14539 PyObject *resultobj = 0;
14540 wxGrid *arg1 = (wxGrid *) 0 ;
14541 bool arg2 = (bool) true ;
14542 void *argp1 = 0 ;
14543 int res1 = 0 ;
14544 bool val2 ;
14545 int ecode2 = 0 ;
14546 PyObject * obj0 = 0 ;
14547 PyObject * obj1 = 0 ;
14548 char * kwnames[] = {
14549 (char *) "self",(char *) "enable", NULL
14550 };
14551
14552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14554 if (!SWIG_IsOK(res1)) {
14555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14556 }
14557 arg1 = reinterpret_cast< wxGrid * >(argp1);
14558 if (obj1) {
14559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14560 if (!SWIG_IsOK(ecode2)) {
14561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14562 }
14563 arg2 = static_cast< bool >(val2);
14564 }
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 (arg1)->EnableDragCell(arg2);
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 resultobj = SWIG_Py_Void();
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14579 PyObject *resultobj = 0;
14580 wxGrid *arg1 = (wxGrid *) 0 ;
14581 void *argp1 = 0 ;
14582 int res1 = 0 ;
14583 PyObject *swig_obj[1] ;
14584
14585 if (!args) SWIG_fail;
14586 swig_obj[0] = args;
14587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14588 if (!SWIG_IsOK(res1)) {
14589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14590 }
14591 arg1 = reinterpret_cast< wxGrid * >(argp1);
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 (arg1)->DisableDragCell();
14595 wxPyEndAllowThreads(__tstate);
14596 if (PyErr_Occurred()) SWIG_fail;
14597 }
14598 resultobj = SWIG_Py_Void();
14599 return resultobj;
14600 fail:
14601 return NULL;
14602 }
14603
14604
14605 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14606 PyObject *resultobj = 0;
14607 wxGrid *arg1 = (wxGrid *) 0 ;
14608 bool result;
14609 void *argp1 = 0 ;
14610 int res1 = 0 ;
14611 PyObject *swig_obj[1] ;
14612
14613 if (!args) SWIG_fail;
14614 swig_obj[0] = args;
14615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14616 if (!SWIG_IsOK(res1)) {
14617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14618 }
14619 arg1 = reinterpret_cast< wxGrid * >(argp1);
14620 {
14621 PyThreadState* __tstate = wxPyBeginAllowThreads();
14622 result = (bool)(arg1)->CanDragCell();
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 {
14627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14628 }
14629 return resultobj;
14630 fail:
14631 return NULL;
14632 }
14633
14634
14635 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14636 PyObject *resultobj = 0;
14637 wxGrid *arg1 = (wxGrid *) 0 ;
14638 int arg2 ;
14639 int arg3 ;
14640 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14641 void *argp1 = 0 ;
14642 int res1 = 0 ;
14643 int val2 ;
14644 int ecode2 = 0 ;
14645 int val3 ;
14646 int ecode3 = 0 ;
14647 void *argp4 = 0 ;
14648 int res4 = 0 ;
14649 PyObject * obj0 = 0 ;
14650 PyObject * obj1 = 0 ;
14651 PyObject * obj2 = 0 ;
14652 PyObject * obj3 = 0 ;
14653 char * kwnames[] = {
14654 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14655 };
14656
14657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14659 if (!SWIG_IsOK(res1)) {
14660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14661 }
14662 arg1 = reinterpret_cast< wxGrid * >(argp1);
14663 ecode2 = SWIG_AsVal_int(obj1, &val2);
14664 if (!SWIG_IsOK(ecode2)) {
14665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14666 }
14667 arg2 = static_cast< int >(val2);
14668 ecode3 = SWIG_AsVal_int(obj2, &val3);
14669 if (!SWIG_IsOK(ecode3)) {
14670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14671 }
14672 arg3 = static_cast< int >(val3);
14673 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14674 if (!SWIG_IsOK(res4)) {
14675 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14676 }
14677 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 (arg1)->SetAttr(arg2,arg3,arg4);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 resultobj = SWIG_Py_Void();
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj = 0;
14693 wxGrid *arg1 = (wxGrid *) 0 ;
14694 int arg2 ;
14695 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14696 void *argp1 = 0 ;
14697 int res1 = 0 ;
14698 int val2 ;
14699 int ecode2 = 0 ;
14700 void *argp3 = 0 ;
14701 int res3 = 0 ;
14702 PyObject * obj0 = 0 ;
14703 PyObject * obj1 = 0 ;
14704 PyObject * obj2 = 0 ;
14705 char * kwnames[] = {
14706 (char *) "self",(char *) "row",(char *) "attr", NULL
14707 };
14708
14709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14711 if (!SWIG_IsOK(res1)) {
14712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14713 }
14714 arg1 = reinterpret_cast< wxGrid * >(argp1);
14715 ecode2 = SWIG_AsVal_int(obj1, &val2);
14716 if (!SWIG_IsOK(ecode2)) {
14717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14718 }
14719 arg2 = static_cast< int >(val2);
14720 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14721 if (!SWIG_IsOK(res3)) {
14722 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14723 }
14724 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 (arg1)->SetRowAttr(arg2,arg3);
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 resultobj = SWIG_Py_Void();
14732 return resultobj;
14733 fail:
14734 return NULL;
14735 }
14736
14737
14738 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14739 PyObject *resultobj = 0;
14740 wxGrid *arg1 = (wxGrid *) 0 ;
14741 int arg2 ;
14742 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14743 void *argp1 = 0 ;
14744 int res1 = 0 ;
14745 int val2 ;
14746 int ecode2 = 0 ;
14747 void *argp3 = 0 ;
14748 int res3 = 0 ;
14749 PyObject * obj0 = 0 ;
14750 PyObject * obj1 = 0 ;
14751 PyObject * obj2 = 0 ;
14752 char * kwnames[] = {
14753 (char *) "self",(char *) "col",(char *) "attr", NULL
14754 };
14755
14756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14760 }
14761 arg1 = reinterpret_cast< wxGrid * >(argp1);
14762 ecode2 = SWIG_AsVal_int(obj1, &val2);
14763 if (!SWIG_IsOK(ecode2)) {
14764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14765 }
14766 arg2 = static_cast< int >(val2);
14767 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14768 if (!SWIG_IsOK(res3)) {
14769 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14770 }
14771 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 (arg1)->SetColAttr(arg2,arg3);
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 resultobj = SWIG_Py_Void();
14779 return resultobj;
14780 fail:
14781 return NULL;
14782 }
14783
14784
14785 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14786 PyObject *resultobj = 0;
14787 wxGrid *arg1 = (wxGrid *) 0 ;
14788 int arg2 ;
14789 int arg3 ;
14790 wxGridCellAttr *result = 0 ;
14791 void *argp1 = 0 ;
14792 int res1 = 0 ;
14793 int val2 ;
14794 int ecode2 = 0 ;
14795 int val3 ;
14796 int ecode3 = 0 ;
14797 PyObject * obj0 = 0 ;
14798 PyObject * obj1 = 0 ;
14799 PyObject * obj2 = 0 ;
14800 char * kwnames[] = {
14801 (char *) "self",(char *) "row",(char *) "col", NULL
14802 };
14803
14804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14806 if (!SWIG_IsOK(res1)) {
14807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14808 }
14809 arg1 = reinterpret_cast< wxGrid * >(argp1);
14810 ecode2 = SWIG_AsVal_int(obj1, &val2);
14811 if (!SWIG_IsOK(ecode2)) {
14812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14813 }
14814 arg2 = static_cast< int >(val2);
14815 ecode3 = SWIG_AsVal_int(obj2, &val3);
14816 if (!SWIG_IsOK(ecode3)) {
14817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14818 }
14819 arg3 = static_cast< int >(val3);
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14828 }
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj = 0;
14837 wxGrid *arg1 = (wxGrid *) 0 ;
14838 int arg2 ;
14839 void *argp1 = 0 ;
14840 int res1 = 0 ;
14841 int val2 ;
14842 int ecode2 = 0 ;
14843 PyObject * obj0 = 0 ;
14844 PyObject * obj1 = 0 ;
14845 char * kwnames[] = {
14846 (char *) "self",(char *) "col", NULL
14847 };
14848
14849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14851 if (!SWIG_IsOK(res1)) {
14852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14853 }
14854 arg1 = reinterpret_cast< wxGrid * >(argp1);
14855 ecode2 = SWIG_AsVal_int(obj1, &val2);
14856 if (!SWIG_IsOK(ecode2)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14858 }
14859 arg2 = static_cast< int >(val2);
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 (arg1)->SetColFormatBool(arg2);
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 resultobj = SWIG_Py_Void();
14867 return resultobj;
14868 fail:
14869 return NULL;
14870 }
14871
14872
14873 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj = 0;
14875 wxGrid *arg1 = (wxGrid *) 0 ;
14876 int arg2 ;
14877 void *argp1 = 0 ;
14878 int res1 = 0 ;
14879 int val2 ;
14880 int ecode2 = 0 ;
14881 PyObject * obj0 = 0 ;
14882 PyObject * obj1 = 0 ;
14883 char * kwnames[] = {
14884 (char *) "self",(char *) "col", NULL
14885 };
14886
14887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14889 if (!SWIG_IsOK(res1)) {
14890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14891 }
14892 arg1 = reinterpret_cast< wxGrid * >(argp1);
14893 ecode2 = SWIG_AsVal_int(obj1, &val2);
14894 if (!SWIG_IsOK(ecode2)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14896 }
14897 arg2 = static_cast< int >(val2);
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 (arg1)->SetColFormatNumber(arg2);
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 resultobj = SWIG_Py_Void();
14905 return resultobj;
14906 fail:
14907 return NULL;
14908 }
14909
14910
14911 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14912 PyObject *resultobj = 0;
14913 wxGrid *arg1 = (wxGrid *) 0 ;
14914 int arg2 ;
14915 int arg3 = (int) -1 ;
14916 int arg4 = (int) -1 ;
14917 void *argp1 = 0 ;
14918 int res1 = 0 ;
14919 int val2 ;
14920 int ecode2 = 0 ;
14921 int val3 ;
14922 int ecode3 = 0 ;
14923 int val4 ;
14924 int ecode4 = 0 ;
14925 PyObject * obj0 = 0 ;
14926 PyObject * obj1 = 0 ;
14927 PyObject * obj2 = 0 ;
14928 PyObject * obj3 = 0 ;
14929 char * kwnames[] = {
14930 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14931 };
14932
14933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14935 if (!SWIG_IsOK(res1)) {
14936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14937 }
14938 arg1 = reinterpret_cast< wxGrid * >(argp1);
14939 ecode2 = SWIG_AsVal_int(obj1, &val2);
14940 if (!SWIG_IsOK(ecode2)) {
14941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14942 }
14943 arg2 = static_cast< int >(val2);
14944 if (obj2) {
14945 ecode3 = SWIG_AsVal_int(obj2, &val3);
14946 if (!SWIG_IsOK(ecode3)) {
14947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14948 }
14949 arg3 = static_cast< int >(val3);
14950 }
14951 if (obj3) {
14952 ecode4 = SWIG_AsVal_int(obj3, &val4);
14953 if (!SWIG_IsOK(ecode4)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14955 }
14956 arg4 = static_cast< int >(val4);
14957 }
14958 {
14959 PyThreadState* __tstate = wxPyBeginAllowThreads();
14960 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 resultobj = SWIG_Py_Void();
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14972 PyObject *resultobj = 0;
14973 wxGrid *arg1 = (wxGrid *) 0 ;
14974 int arg2 ;
14975 wxString *arg3 = 0 ;
14976 void *argp1 = 0 ;
14977 int res1 = 0 ;
14978 int val2 ;
14979 int ecode2 = 0 ;
14980 bool temp3 = false ;
14981 PyObject * obj0 = 0 ;
14982 PyObject * obj1 = 0 ;
14983 PyObject * obj2 = 0 ;
14984 char * kwnames[] = {
14985 (char *) "self",(char *) "col",(char *) "typeName", NULL
14986 };
14987
14988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14990 if (!SWIG_IsOK(res1)) {
14991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14992 }
14993 arg1 = reinterpret_cast< wxGrid * >(argp1);
14994 ecode2 = SWIG_AsVal_int(obj1, &val2);
14995 if (!SWIG_IsOK(ecode2)) {
14996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14997 }
14998 arg2 = static_cast< int >(val2);
14999 {
15000 arg3 = wxString_in_helper(obj2);
15001 if (arg3 == NULL) SWIG_fail;
15002 temp3 = true;
15003 }
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15007 wxPyEndAllowThreads(__tstate);
15008 if (PyErr_Occurred()) SWIG_fail;
15009 }
15010 resultobj = SWIG_Py_Void();
15011 {
15012 if (temp3)
15013 delete arg3;
15014 }
15015 return resultobj;
15016 fail:
15017 {
15018 if (temp3)
15019 delete arg3;
15020 }
15021 return NULL;
15022 }
15023
15024
15025 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj = 0;
15027 wxGrid *arg1 = (wxGrid *) 0 ;
15028 bool arg2 = (bool) true ;
15029 void *argp1 = 0 ;
15030 int res1 = 0 ;
15031 bool val2 ;
15032 int ecode2 = 0 ;
15033 PyObject * obj0 = 0 ;
15034 PyObject * obj1 = 0 ;
15035 char * kwnames[] = {
15036 (char *) "self",(char *) "enable", NULL
15037 };
15038
15039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15043 }
15044 arg1 = reinterpret_cast< wxGrid * >(argp1);
15045 if (obj1) {
15046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15047 if (!SWIG_IsOK(ecode2)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15049 }
15050 arg2 = static_cast< bool >(val2);
15051 }
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 (arg1)->EnableGridLines(arg2);
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_Py_Void();
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15066 PyObject *resultobj = 0;
15067 wxGrid *arg1 = (wxGrid *) 0 ;
15068 bool result;
15069 void *argp1 = 0 ;
15070 int res1 = 0 ;
15071 PyObject *swig_obj[1] ;
15072
15073 if (!args) SWIG_fail;
15074 swig_obj[0] = args;
15075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15078 }
15079 arg1 = reinterpret_cast< wxGrid * >(argp1);
15080 {
15081 PyThreadState* __tstate = wxPyBeginAllowThreads();
15082 result = (bool)(arg1)->GridLinesEnabled();
15083 wxPyEndAllowThreads(__tstate);
15084 if (PyErr_Occurred()) SWIG_fail;
15085 }
15086 {
15087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15088 }
15089 return resultobj;
15090 fail:
15091 return NULL;
15092 }
15093
15094
15095 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15096 PyObject *resultobj = 0;
15097 wxGrid *arg1 = (wxGrid *) 0 ;
15098 int result;
15099 void *argp1 = 0 ;
15100 int res1 = 0 ;
15101 PyObject *swig_obj[1] ;
15102
15103 if (!args) SWIG_fail;
15104 swig_obj[0] = args;
15105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15106 if (!SWIG_IsOK(res1)) {
15107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15108 }
15109 arg1 = reinterpret_cast< wxGrid * >(argp1);
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (int)(arg1)->GetDefaultRowSize();
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 resultobj = SWIG_From_int(static_cast< int >(result));
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = 0;
15125 wxGrid *arg1 = (wxGrid *) 0 ;
15126 int arg2 ;
15127 int result;
15128 void *argp1 = 0 ;
15129 int res1 = 0 ;
15130 int val2 ;
15131 int ecode2 = 0 ;
15132 PyObject * obj0 = 0 ;
15133 PyObject * obj1 = 0 ;
15134 char * kwnames[] = {
15135 (char *) "self",(char *) "row", NULL
15136 };
15137
15138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15140 if (!SWIG_IsOK(res1)) {
15141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15142 }
15143 arg1 = reinterpret_cast< wxGrid * >(argp1);
15144 ecode2 = SWIG_AsVal_int(obj1, &val2);
15145 if (!SWIG_IsOK(ecode2)) {
15146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15147 }
15148 arg2 = static_cast< int >(val2);
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (int)(arg1)->GetRowSize(arg2);
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 resultobj = SWIG_From_int(static_cast< int >(result));
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15163 PyObject *resultobj = 0;
15164 wxGrid *arg1 = (wxGrid *) 0 ;
15165 int result;
15166 void *argp1 = 0 ;
15167 int res1 = 0 ;
15168 PyObject *swig_obj[1] ;
15169
15170 if (!args) SWIG_fail;
15171 swig_obj[0] = args;
15172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15173 if (!SWIG_IsOK(res1)) {
15174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15175 }
15176 arg1 = reinterpret_cast< wxGrid * >(argp1);
15177 {
15178 PyThreadState* __tstate = wxPyBeginAllowThreads();
15179 result = (int)(arg1)->GetDefaultColSize();
15180 wxPyEndAllowThreads(__tstate);
15181 if (PyErr_Occurred()) SWIG_fail;
15182 }
15183 resultobj = SWIG_From_int(static_cast< int >(result));
15184 return resultobj;
15185 fail:
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = 0;
15192 wxGrid *arg1 = (wxGrid *) 0 ;
15193 int arg2 ;
15194 int result;
15195 void *argp1 = 0 ;
15196 int res1 = 0 ;
15197 int val2 ;
15198 int ecode2 = 0 ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 char * kwnames[] = {
15202 (char *) "self",(char *) "col", NULL
15203 };
15204
15205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15207 if (!SWIG_IsOK(res1)) {
15208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15209 }
15210 arg1 = reinterpret_cast< wxGrid * >(argp1);
15211 ecode2 = SWIG_AsVal_int(obj1, &val2);
15212 if (!SWIG_IsOK(ecode2)) {
15213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15214 }
15215 arg2 = static_cast< int >(val2);
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (int)(arg1)->GetColSize(arg2);
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_From_int(static_cast< int >(result));
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15230 PyObject *resultobj = 0;
15231 wxGrid *arg1 = (wxGrid *) 0 ;
15232 wxColour result;
15233 void *argp1 = 0 ;
15234 int res1 = 0 ;
15235 PyObject *swig_obj[1] ;
15236
15237 if (!args) SWIG_fail;
15238 swig_obj[0] = args;
15239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15240 if (!SWIG_IsOK(res1)) {
15241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15242 }
15243 arg1 = reinterpret_cast< wxGrid * >(argp1);
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 result = (arg1)->GetDefaultCellBackgroundColour();
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15251 return resultobj;
15252 fail:
15253 return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15258 PyObject *resultobj = 0;
15259 wxGrid *arg1 = (wxGrid *) 0 ;
15260 int arg2 ;
15261 int arg3 ;
15262 wxColour result;
15263 void *argp1 = 0 ;
15264 int res1 = 0 ;
15265 int val2 ;
15266 int ecode2 = 0 ;
15267 int val3 ;
15268 int ecode3 = 0 ;
15269 PyObject * obj0 = 0 ;
15270 PyObject * obj1 = 0 ;
15271 PyObject * obj2 = 0 ;
15272 char * kwnames[] = {
15273 (char *) "self",(char *) "row",(char *) "col", NULL
15274 };
15275
15276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15278 if (!SWIG_IsOK(res1)) {
15279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15280 }
15281 arg1 = reinterpret_cast< wxGrid * >(argp1);
15282 ecode2 = SWIG_AsVal_int(obj1, &val2);
15283 if (!SWIG_IsOK(ecode2)) {
15284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15285 }
15286 arg2 = static_cast< int >(val2);
15287 ecode3 = SWIG_AsVal_int(obj2, &val3);
15288 if (!SWIG_IsOK(ecode3)) {
15289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15290 }
15291 arg3 = static_cast< int >(val3);
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15306 PyObject *resultobj = 0;
15307 wxGrid *arg1 = (wxGrid *) 0 ;
15308 wxColour result;
15309 void *argp1 = 0 ;
15310 int res1 = 0 ;
15311 PyObject *swig_obj[1] ;
15312
15313 if (!args) SWIG_fail;
15314 swig_obj[0] = args;
15315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15316 if (!SWIG_IsOK(res1)) {
15317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15318 }
15319 arg1 = reinterpret_cast< wxGrid * >(argp1);
15320 {
15321 PyThreadState* __tstate = wxPyBeginAllowThreads();
15322 result = (arg1)->GetDefaultCellTextColour();
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj = 0;
15335 wxGrid *arg1 = (wxGrid *) 0 ;
15336 int arg2 ;
15337 int arg3 ;
15338 wxColour result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 int val2 ;
15342 int ecode2 = 0 ;
15343 int val3 ;
15344 int ecode3 = 0 ;
15345 PyObject * obj0 = 0 ;
15346 PyObject * obj1 = 0 ;
15347 PyObject * obj2 = 0 ;
15348 char * kwnames[] = {
15349 (char *) "self",(char *) "row",(char *) "col", NULL
15350 };
15351
15352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15354 if (!SWIG_IsOK(res1)) {
15355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15356 }
15357 arg1 = reinterpret_cast< wxGrid * >(argp1);
15358 ecode2 = SWIG_AsVal_int(obj1, &val2);
15359 if (!SWIG_IsOK(ecode2)) {
15360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15361 }
15362 arg2 = static_cast< int >(val2);
15363 ecode3 = SWIG_AsVal_int(obj2, &val3);
15364 if (!SWIG_IsOK(ecode3)) {
15365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15366 }
15367 arg3 = static_cast< int >(val3);
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 result = (arg1)->GetCellTextColour(arg2,arg3);
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxGrid *arg1 = (wxGrid *) 0 ;
15384 wxFont result;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject *swig_obj[1] ;
15388
15389 if (!args) SWIG_fail;
15390 swig_obj[0] = args;
15391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15394 }
15395 arg1 = reinterpret_cast< wxGrid * >(argp1);
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 result = (arg1)->GetDefaultCellFont();
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = 0;
15411 wxGrid *arg1 = (wxGrid *) 0 ;
15412 int arg2 ;
15413 int arg3 ;
15414 wxFont result;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 int val2 ;
15418 int ecode2 = 0 ;
15419 int val3 ;
15420 int ecode3 = 0 ;
15421 PyObject * obj0 = 0 ;
15422 PyObject * obj1 = 0 ;
15423 PyObject * obj2 = 0 ;
15424 char * kwnames[] = {
15425 (char *) "self",(char *) "row",(char *) "col", NULL
15426 };
15427
15428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15430 if (!SWIG_IsOK(res1)) {
15431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15432 }
15433 arg1 = reinterpret_cast< wxGrid * >(argp1);
15434 ecode2 = SWIG_AsVal_int(obj1, &val2);
15435 if (!SWIG_IsOK(ecode2)) {
15436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15437 }
15438 arg2 = static_cast< int >(val2);
15439 ecode3 = SWIG_AsVal_int(obj2, &val3);
15440 if (!SWIG_IsOK(ecode3)) {
15441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15442 }
15443 arg3 = static_cast< int >(val3);
15444 {
15445 PyThreadState* __tstate = wxPyBeginAllowThreads();
15446 result = (arg1)->GetCellFont(arg2,arg3);
15447 wxPyEndAllowThreads(__tstate);
15448 if (PyErr_Occurred()) SWIG_fail;
15449 }
15450 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15451 return resultobj;
15452 fail:
15453 return NULL;
15454 }
15455
15456
15457 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15458 PyObject *resultobj = 0;
15459 wxGrid *arg1 = (wxGrid *) 0 ;
15460 int *arg2 = (int *) 0 ;
15461 int *arg3 = (int *) 0 ;
15462 void *argp1 = 0 ;
15463 int res1 = 0 ;
15464 int temp2 ;
15465 int res2 = SWIG_TMPOBJ ;
15466 int temp3 ;
15467 int res3 = SWIG_TMPOBJ ;
15468 PyObject *swig_obj[1] ;
15469
15470 arg2 = &temp2;
15471 arg3 = &temp3;
15472 if (!args) SWIG_fail;
15473 swig_obj[0] = args;
15474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15475 if (!SWIG_IsOK(res1)) {
15476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15477 }
15478 arg1 = reinterpret_cast< wxGrid * >(argp1);
15479 {
15480 PyThreadState* __tstate = wxPyBeginAllowThreads();
15481 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15482 wxPyEndAllowThreads(__tstate);
15483 if (PyErr_Occurred()) SWIG_fail;
15484 }
15485 resultobj = SWIG_Py_Void();
15486 if (SWIG_IsTmpObj(res2)) {
15487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15488 } else {
15489 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15491 }
15492 if (SWIG_IsTmpObj(res3)) {
15493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15494 } else {
15495 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15497 }
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = 0;
15506 wxGrid *arg1 = (wxGrid *) 0 ;
15507 int arg2 ;
15508 int arg3 ;
15509 int *arg4 = (int *) 0 ;
15510 int *arg5 = (int *) 0 ;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 int val2 ;
15514 int ecode2 = 0 ;
15515 int val3 ;
15516 int ecode3 = 0 ;
15517 int temp4 ;
15518 int res4 = SWIG_TMPOBJ ;
15519 int temp5 ;
15520 int res5 = SWIG_TMPOBJ ;
15521 PyObject * obj0 = 0 ;
15522 PyObject * obj1 = 0 ;
15523 PyObject * obj2 = 0 ;
15524 char * kwnames[] = {
15525 (char *) "self",(char *) "row",(char *) "col", NULL
15526 };
15527
15528 arg4 = &temp4;
15529 arg5 = &temp5;
15530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15534 }
15535 arg1 = reinterpret_cast< wxGrid * >(argp1);
15536 ecode2 = SWIG_AsVal_int(obj1, &val2);
15537 if (!SWIG_IsOK(ecode2)) {
15538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15539 }
15540 arg2 = static_cast< int >(val2);
15541 ecode3 = SWIG_AsVal_int(obj2, &val3);
15542 if (!SWIG_IsOK(ecode3)) {
15543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15544 }
15545 arg3 = static_cast< int >(val3);
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 resultobj = SWIG_Py_Void();
15553 if (SWIG_IsTmpObj(res4)) {
15554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15555 } else {
15556 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15558 }
15559 if (SWIG_IsTmpObj(res5)) {
15560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15561 } else {
15562 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15564 }
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15572 PyObject *resultobj = 0;
15573 wxGrid *arg1 = (wxGrid *) 0 ;
15574 bool result;
15575 void *argp1 = 0 ;
15576 int res1 = 0 ;
15577 PyObject *swig_obj[1] ;
15578
15579 if (!args) SWIG_fail;
15580 swig_obj[0] = args;
15581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15582 if (!SWIG_IsOK(res1)) {
15583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15584 }
15585 arg1 = reinterpret_cast< wxGrid * >(argp1);
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 result = (bool)(arg1)->GetDefaultCellOverflow();
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 {
15593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15594 }
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj = 0;
15603 wxGrid *arg1 = (wxGrid *) 0 ;
15604 int arg2 ;
15605 int arg3 ;
15606 bool result;
15607 void *argp1 = 0 ;
15608 int res1 = 0 ;
15609 int val2 ;
15610 int ecode2 = 0 ;
15611 int val3 ;
15612 int ecode3 = 0 ;
15613 PyObject * obj0 = 0 ;
15614 PyObject * obj1 = 0 ;
15615 PyObject * obj2 = 0 ;
15616 char * kwnames[] = {
15617 (char *) "self",(char *) "row",(char *) "col", NULL
15618 };
15619
15620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15622 if (!SWIG_IsOK(res1)) {
15623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15624 }
15625 arg1 = reinterpret_cast< wxGrid * >(argp1);
15626 ecode2 = SWIG_AsVal_int(obj1, &val2);
15627 if (!SWIG_IsOK(ecode2)) {
15628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15629 }
15630 arg2 = static_cast< int >(val2);
15631 ecode3 = SWIG_AsVal_int(obj2, &val3);
15632 if (!SWIG_IsOK(ecode3)) {
15633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15634 }
15635 arg3 = static_cast< int >(val3);
15636 {
15637 PyThreadState* __tstate = wxPyBeginAllowThreads();
15638 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 {
15643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15644 }
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj = 0;
15653 wxGrid *arg1 = (wxGrid *) 0 ;
15654 int arg2 ;
15655 int arg3 ;
15656 int *arg4 = (int *) 0 ;
15657 int *arg5 = (int *) 0 ;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 int val2 ;
15661 int ecode2 = 0 ;
15662 int val3 ;
15663 int ecode3 = 0 ;
15664 int temp4 ;
15665 int res4 = SWIG_TMPOBJ ;
15666 int temp5 ;
15667 int res5 = SWIG_TMPOBJ ;
15668 PyObject * obj0 = 0 ;
15669 PyObject * obj1 = 0 ;
15670 PyObject * obj2 = 0 ;
15671 char * kwnames[] = {
15672 (char *) "self",(char *) "row",(char *) "col", NULL
15673 };
15674
15675 arg4 = &temp4;
15676 arg5 = &temp5;
15677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",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_GetCellSize" "', 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_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15686 }
15687 arg2 = static_cast< int >(val2);
15688 ecode3 = SWIG_AsVal_int(obj2, &val3);
15689 if (!SWIG_IsOK(ecode3)) {
15690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15691 }
15692 arg3 = static_cast< int >(val3);
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 resultobj = SWIG_Py_Void();
15700 if (SWIG_IsTmpObj(res4)) {
15701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15702 } else {
15703 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15705 }
15706 if (SWIG_IsTmpObj(res5)) {
15707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15708 } else {
15709 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj = 0;
15720 wxGrid *arg1 = (wxGrid *) 0 ;
15721 int arg2 ;
15722 bool arg3 = (bool) false ;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 int val2 ;
15726 int ecode2 = 0 ;
15727 bool val3 ;
15728 int ecode3 = 0 ;
15729 PyObject * obj0 = 0 ;
15730 PyObject * obj1 = 0 ;
15731 PyObject * obj2 = 0 ;
15732 char * kwnames[] = {
15733 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15734 };
15735
15736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15738 if (!SWIG_IsOK(res1)) {
15739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15740 }
15741 arg1 = reinterpret_cast< wxGrid * >(argp1);
15742 ecode2 = SWIG_AsVal_int(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15745 }
15746 arg2 = static_cast< int >(val2);
15747 if (obj2) {
15748 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15749 if (!SWIG_IsOK(ecode3)) {
15750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15751 }
15752 arg3 = static_cast< bool >(val3);
15753 }
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 (arg1)->SetDefaultRowSize(arg2,arg3);
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 resultobj = SWIG_Py_Void();
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = 0;
15769 wxGrid *arg1 = (wxGrid *) 0 ;
15770 int arg2 ;
15771 int arg3 ;
15772 void *argp1 = 0 ;
15773 int res1 = 0 ;
15774 int val2 ;
15775 int ecode2 = 0 ;
15776 int val3 ;
15777 int ecode3 = 0 ;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 PyObject * obj2 = 0 ;
15781 char * kwnames[] = {
15782 (char *) "self",(char *) "row",(char *) "height", NULL
15783 };
15784
15785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15789 }
15790 arg1 = reinterpret_cast< wxGrid * >(argp1);
15791 ecode2 = SWIG_AsVal_int(obj1, &val2);
15792 if (!SWIG_IsOK(ecode2)) {
15793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15794 }
15795 arg2 = static_cast< int >(val2);
15796 ecode3 = SWIG_AsVal_int(obj2, &val3);
15797 if (!SWIG_IsOK(ecode3)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15799 }
15800 arg3 = static_cast< int >(val3);
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 (arg1)->SetRowSize(arg2,arg3);
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 resultobj = SWIG_Py_Void();
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj = 0;
15816 wxGrid *arg1 = (wxGrid *) 0 ;
15817 int arg2 ;
15818 bool arg3 = (bool) false ;
15819 void *argp1 = 0 ;
15820 int res1 = 0 ;
15821 int val2 ;
15822 int ecode2 = 0 ;
15823 bool val3 ;
15824 int ecode3 = 0 ;
15825 PyObject * obj0 = 0 ;
15826 PyObject * obj1 = 0 ;
15827 PyObject * obj2 = 0 ;
15828 char * kwnames[] = {
15829 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15830 };
15831
15832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15836 }
15837 arg1 = reinterpret_cast< wxGrid * >(argp1);
15838 ecode2 = SWIG_AsVal_int(obj1, &val2);
15839 if (!SWIG_IsOK(ecode2)) {
15840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15841 }
15842 arg2 = static_cast< int >(val2);
15843 if (obj2) {
15844 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15845 if (!SWIG_IsOK(ecode3)) {
15846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15847 }
15848 arg3 = static_cast< bool >(val3);
15849 }
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 (arg1)->SetDefaultColSize(arg2,arg3);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_Py_Void();
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 wxGrid *arg1 = (wxGrid *) 0 ;
15866 int arg2 ;
15867 int arg3 ;
15868 void *argp1 = 0 ;
15869 int res1 = 0 ;
15870 int val2 ;
15871 int ecode2 = 0 ;
15872 int val3 ;
15873 int ecode3 = 0 ;
15874 PyObject * obj0 = 0 ;
15875 PyObject * obj1 = 0 ;
15876 PyObject * obj2 = 0 ;
15877 char * kwnames[] = {
15878 (char *) "self",(char *) "col",(char *) "width", NULL
15879 };
15880
15881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15883 if (!SWIG_IsOK(res1)) {
15884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15885 }
15886 arg1 = reinterpret_cast< wxGrid * >(argp1);
15887 ecode2 = SWIG_AsVal_int(obj1, &val2);
15888 if (!SWIG_IsOK(ecode2)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15890 }
15891 arg2 = static_cast< int >(val2);
15892 ecode3 = SWIG_AsVal_int(obj2, &val3);
15893 if (!SWIG_IsOK(ecode3)) {
15894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15895 }
15896 arg3 = static_cast< int >(val3);
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 (arg1)->SetColSize(arg2,arg3);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_Py_Void();
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = 0;
15912 wxGrid *arg1 = (wxGrid *) 0 ;
15913 int arg2 ;
15914 int result;
15915 void *argp1 = 0 ;
15916 int res1 = 0 ;
15917 int val2 ;
15918 int ecode2 = 0 ;
15919 PyObject * obj0 = 0 ;
15920 PyObject * obj1 = 0 ;
15921 char * kwnames[] = {
15922 (char *) "self",(char *) "colPos", NULL
15923 };
15924
15925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15927 if (!SWIG_IsOK(res1)) {
15928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15929 }
15930 arg1 = reinterpret_cast< wxGrid * >(argp1);
15931 ecode2 = SWIG_AsVal_int(obj1, &val2);
15932 if (!SWIG_IsOK(ecode2)) {
15933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15934 }
15935 arg2 = static_cast< int >(val2);
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15939 wxPyEndAllowThreads(__tstate);
15940 if (PyErr_Occurred()) SWIG_fail;
15941 }
15942 resultobj = SWIG_From_int(static_cast< int >(result));
15943 return resultobj;
15944 fail:
15945 return NULL;
15946 }
15947
15948
15949 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15950 PyObject *resultobj = 0;
15951 wxGrid *arg1 = (wxGrid *) 0 ;
15952 int arg2 ;
15953 int arg3 ;
15954 void *argp1 = 0 ;
15955 int res1 = 0 ;
15956 int val2 ;
15957 int ecode2 = 0 ;
15958 int val3 ;
15959 int ecode3 = 0 ;
15960 PyObject * obj0 = 0 ;
15961 PyObject * obj1 = 0 ;
15962 PyObject * obj2 = 0 ;
15963 char * kwnames[] = {
15964 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15965 };
15966
15967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15969 if (!SWIG_IsOK(res1)) {
15970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15971 }
15972 arg1 = reinterpret_cast< wxGrid * >(argp1);
15973 ecode2 = SWIG_AsVal_int(obj1, &val2);
15974 if (!SWIG_IsOK(ecode2)) {
15975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15976 }
15977 arg2 = static_cast< int >(val2);
15978 ecode3 = SWIG_AsVal_int(obj2, &val3);
15979 if (!SWIG_IsOK(ecode3)) {
15980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15981 }
15982 arg3 = static_cast< int >(val3);
15983 {
15984 PyThreadState* __tstate = wxPyBeginAllowThreads();
15985 (arg1)->SetColPos(arg2,arg3);
15986 wxPyEndAllowThreads(__tstate);
15987 if (PyErr_Occurred()) SWIG_fail;
15988 }
15989 resultobj = SWIG_Py_Void();
15990 return resultobj;
15991 fail:
15992 return NULL;
15993 }
15994
15995
15996 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15997 PyObject *resultobj = 0;
15998 wxGrid *arg1 = (wxGrid *) 0 ;
15999 int arg2 ;
16000 int result;
16001 void *argp1 = 0 ;
16002 int res1 = 0 ;
16003 int val2 ;
16004 int ecode2 = 0 ;
16005 PyObject * obj0 = 0 ;
16006 PyObject * obj1 = 0 ;
16007 char * kwnames[] = {
16008 (char *) "self",(char *) "colID", NULL
16009 };
16010
16011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16013 if (!SWIG_IsOK(res1)) {
16014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16015 }
16016 arg1 = reinterpret_cast< wxGrid * >(argp1);
16017 ecode2 = SWIG_AsVal_int(obj1, &val2);
16018 if (!SWIG_IsOK(ecode2)) {
16019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16020 }
16021 arg2 = static_cast< int >(val2);
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 resultobj = SWIG_From_int(static_cast< int >(result));
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxGrid *arg1 = (wxGrid *) 0 ;
16038 int arg2 ;
16039 bool arg3 = (bool) true ;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 int val2 ;
16043 int ecode2 = 0 ;
16044 bool val3 ;
16045 int ecode3 = 0 ;
16046 PyObject * obj0 = 0 ;
16047 PyObject * obj1 = 0 ;
16048 PyObject * obj2 = 0 ;
16049 char * kwnames[] = {
16050 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16051 };
16052
16053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16055 if (!SWIG_IsOK(res1)) {
16056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16057 }
16058 arg1 = reinterpret_cast< wxGrid * >(argp1);
16059 ecode2 = SWIG_AsVal_int(obj1, &val2);
16060 if (!SWIG_IsOK(ecode2)) {
16061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16062 }
16063 arg2 = static_cast< int >(val2);
16064 if (obj2) {
16065 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16066 if (!SWIG_IsOK(ecode3)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16068 }
16069 arg3 = static_cast< bool >(val3);
16070 }
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 (arg1)->AutoSizeColumn(arg2,arg3);
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_Py_Void();
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj = 0;
16086 wxGrid *arg1 = (wxGrid *) 0 ;
16087 int arg2 ;
16088 bool arg3 = (bool) true ;
16089 void *argp1 = 0 ;
16090 int res1 = 0 ;
16091 int val2 ;
16092 int ecode2 = 0 ;
16093 bool val3 ;
16094 int ecode3 = 0 ;
16095 PyObject * obj0 = 0 ;
16096 PyObject * obj1 = 0 ;
16097 PyObject * obj2 = 0 ;
16098 char * kwnames[] = {
16099 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16100 };
16101
16102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16106 }
16107 arg1 = reinterpret_cast< wxGrid * >(argp1);
16108 ecode2 = SWIG_AsVal_int(obj1, &val2);
16109 if (!SWIG_IsOK(ecode2)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16111 }
16112 arg2 = static_cast< int >(val2);
16113 if (obj2) {
16114 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16115 if (!SWIG_IsOK(ecode3)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16117 }
16118 arg3 = static_cast< bool >(val3);
16119 }
16120 {
16121 PyThreadState* __tstate = wxPyBeginAllowThreads();
16122 (arg1)->AutoSizeRow(arg2,arg3);
16123 wxPyEndAllowThreads(__tstate);
16124 if (PyErr_Occurred()) SWIG_fail;
16125 }
16126 resultobj = SWIG_Py_Void();
16127 return resultobj;
16128 fail:
16129 return NULL;
16130 }
16131
16132
16133 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16134 PyObject *resultobj = 0;
16135 wxGrid *arg1 = (wxGrid *) 0 ;
16136 bool arg2 = (bool) true ;
16137 void *argp1 = 0 ;
16138 int res1 = 0 ;
16139 bool val2 ;
16140 int ecode2 = 0 ;
16141 PyObject * obj0 = 0 ;
16142 PyObject * obj1 = 0 ;
16143 char * kwnames[] = {
16144 (char *) "self",(char *) "setAsMin", NULL
16145 };
16146
16147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16151 }
16152 arg1 = reinterpret_cast< wxGrid * >(argp1);
16153 if (obj1) {
16154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16155 if (!SWIG_IsOK(ecode2)) {
16156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16157 }
16158 arg2 = static_cast< bool >(val2);
16159 }
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 (arg1)->AutoSizeColumns(arg2);
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 resultobj = SWIG_Py_Void();
16167 return resultobj;
16168 fail:
16169 return NULL;
16170 }
16171
16172
16173 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16174 PyObject *resultobj = 0;
16175 wxGrid *arg1 = (wxGrid *) 0 ;
16176 bool arg2 = (bool) true ;
16177 void *argp1 = 0 ;
16178 int res1 = 0 ;
16179 bool val2 ;
16180 int ecode2 = 0 ;
16181 PyObject * obj0 = 0 ;
16182 PyObject * obj1 = 0 ;
16183 char * kwnames[] = {
16184 (char *) "self",(char *) "setAsMin", NULL
16185 };
16186
16187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16189 if (!SWIG_IsOK(res1)) {
16190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16191 }
16192 arg1 = reinterpret_cast< wxGrid * >(argp1);
16193 if (obj1) {
16194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16195 if (!SWIG_IsOK(ecode2)) {
16196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16197 }
16198 arg2 = static_cast< bool >(val2);
16199 }
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 (arg1)->AutoSizeRows(arg2);
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_Py_Void();
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16214 PyObject *resultobj = 0;
16215 wxGrid *arg1 = (wxGrid *) 0 ;
16216 void *argp1 = 0 ;
16217 int res1 = 0 ;
16218 PyObject *swig_obj[1] ;
16219
16220 if (!args) SWIG_fail;
16221 swig_obj[0] = args;
16222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16223 if (!SWIG_IsOK(res1)) {
16224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16225 }
16226 arg1 = reinterpret_cast< wxGrid * >(argp1);
16227 {
16228 PyThreadState* __tstate = wxPyBeginAllowThreads();
16229 (arg1)->AutoSize();
16230 wxPyEndAllowThreads(__tstate);
16231 if (PyErr_Occurred()) SWIG_fail;
16232 }
16233 resultobj = SWIG_Py_Void();
16234 return resultobj;
16235 fail:
16236 return NULL;
16237 }
16238
16239
16240 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16241 PyObject *resultobj = 0;
16242 wxGrid *arg1 = (wxGrid *) 0 ;
16243 int arg2 ;
16244 void *argp1 = 0 ;
16245 int res1 = 0 ;
16246 int val2 ;
16247 int ecode2 = 0 ;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 char * kwnames[] = {
16251 (char *) "self",(char *) "row", NULL
16252 };
16253
16254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16256 if (!SWIG_IsOK(res1)) {
16257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16258 }
16259 arg1 = reinterpret_cast< wxGrid * >(argp1);
16260 ecode2 = SWIG_AsVal_int(obj1, &val2);
16261 if (!SWIG_IsOK(ecode2)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16263 }
16264 arg2 = static_cast< int >(val2);
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 (arg1)->AutoSizeRowLabelSize(arg2);
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 resultobj = SWIG_Py_Void();
16272 return resultobj;
16273 fail:
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = 0;
16280 wxGrid *arg1 = (wxGrid *) 0 ;
16281 int arg2 ;
16282 void *argp1 = 0 ;
16283 int res1 = 0 ;
16284 int val2 ;
16285 int ecode2 = 0 ;
16286 PyObject * obj0 = 0 ;
16287 PyObject * obj1 = 0 ;
16288 char * kwnames[] = {
16289 (char *) "self",(char *) "col", NULL
16290 };
16291
16292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16294 if (!SWIG_IsOK(res1)) {
16295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16296 }
16297 arg1 = reinterpret_cast< wxGrid * >(argp1);
16298 ecode2 = SWIG_AsVal_int(obj1, &val2);
16299 if (!SWIG_IsOK(ecode2)) {
16300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16301 }
16302 arg2 = static_cast< int >(val2);
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 (arg1)->AutoSizeColLabelSize(arg2);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_Py_Void();
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj = 0;
16318 wxGrid *arg1 = (wxGrid *) 0 ;
16319 int arg2 ;
16320 int arg3 ;
16321 void *argp1 = 0 ;
16322 int res1 = 0 ;
16323 int val2 ;
16324 int ecode2 = 0 ;
16325 int val3 ;
16326 int ecode3 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 PyObject * obj2 = 0 ;
16330 char * kwnames[] = {
16331 (char *) "self",(char *) "col",(char *) "width", NULL
16332 };
16333
16334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16338 }
16339 arg1 = reinterpret_cast< wxGrid * >(argp1);
16340 ecode2 = SWIG_AsVal_int(obj1, &val2);
16341 if (!SWIG_IsOK(ecode2)) {
16342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16343 }
16344 arg2 = static_cast< int >(val2);
16345 ecode3 = SWIG_AsVal_int(obj2, &val3);
16346 if (!SWIG_IsOK(ecode3)) {
16347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16348 }
16349 arg3 = static_cast< int >(val3);
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetColMinimalWidth(arg2,arg3);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_Py_Void();
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj = 0;
16365 wxGrid *arg1 = (wxGrid *) 0 ;
16366 int arg2 ;
16367 int arg3 ;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 int val2 ;
16371 int ecode2 = 0 ;
16372 int val3 ;
16373 int ecode3 = 0 ;
16374 PyObject * obj0 = 0 ;
16375 PyObject * obj1 = 0 ;
16376 PyObject * obj2 = 0 ;
16377 char * kwnames[] = {
16378 (char *) "self",(char *) "row",(char *) "width", NULL
16379 };
16380
16381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16383 if (!SWIG_IsOK(res1)) {
16384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16385 }
16386 arg1 = reinterpret_cast< wxGrid * >(argp1);
16387 ecode2 = SWIG_AsVal_int(obj1, &val2);
16388 if (!SWIG_IsOK(ecode2)) {
16389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16390 }
16391 arg2 = static_cast< int >(val2);
16392 ecode3 = SWIG_AsVal_int(obj2, &val3);
16393 if (!SWIG_IsOK(ecode3)) {
16394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16395 }
16396 arg3 = static_cast< int >(val3);
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 (arg1)->SetRowMinimalHeight(arg2,arg3);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 resultobj = SWIG_Py_Void();
16404 return resultobj;
16405 fail:
16406 return NULL;
16407 }
16408
16409
16410 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj = 0;
16412 wxGrid *arg1 = (wxGrid *) 0 ;
16413 int arg2 ;
16414 void *argp1 = 0 ;
16415 int res1 = 0 ;
16416 int val2 ;
16417 int ecode2 = 0 ;
16418 PyObject * obj0 = 0 ;
16419 PyObject * obj1 = 0 ;
16420 char * kwnames[] = {
16421 (char *) "self",(char *) "width", NULL
16422 };
16423
16424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16426 if (!SWIG_IsOK(res1)) {
16427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16428 }
16429 arg1 = reinterpret_cast< wxGrid * >(argp1);
16430 ecode2 = SWIG_AsVal_int(obj1, &val2);
16431 if (!SWIG_IsOK(ecode2)) {
16432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16433 }
16434 arg2 = static_cast< int >(val2);
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 (arg1)->SetColMinimalAcceptableWidth(arg2);
16438 wxPyEndAllowThreads(__tstate);
16439 if (PyErr_Occurred()) SWIG_fail;
16440 }
16441 resultobj = SWIG_Py_Void();
16442 return resultobj;
16443 fail:
16444 return NULL;
16445 }
16446
16447
16448 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16449 PyObject *resultobj = 0;
16450 wxGrid *arg1 = (wxGrid *) 0 ;
16451 int arg2 ;
16452 void *argp1 = 0 ;
16453 int res1 = 0 ;
16454 int val2 ;
16455 int ecode2 = 0 ;
16456 PyObject * obj0 = 0 ;
16457 PyObject * obj1 = 0 ;
16458 char * kwnames[] = {
16459 (char *) "self",(char *) "width", NULL
16460 };
16461
16462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16464 if (!SWIG_IsOK(res1)) {
16465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16466 }
16467 arg1 = reinterpret_cast< wxGrid * >(argp1);
16468 ecode2 = SWIG_AsVal_int(obj1, &val2);
16469 if (!SWIG_IsOK(ecode2)) {
16470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16471 }
16472 arg2 = static_cast< int >(val2);
16473 {
16474 PyThreadState* __tstate = wxPyBeginAllowThreads();
16475 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_Py_Void();
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16487 PyObject *resultobj = 0;
16488 wxGrid *arg1 = (wxGrid *) 0 ;
16489 int result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 PyObject *swig_obj[1] ;
16493
16494 if (!args) SWIG_fail;
16495 swig_obj[0] = args;
16496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16499 }
16500 arg1 = reinterpret_cast< wxGrid * >(argp1);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_From_int(static_cast< int >(result));
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 PyObject *resultobj = 0;
16516 wxGrid *arg1 = (wxGrid *) 0 ;
16517 int result;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 PyObject *swig_obj[1] ;
16521
16522 if (!args) SWIG_fail;
16523 swig_obj[0] = args;
16524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16525 if (!SWIG_IsOK(res1)) {
16526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16527 }
16528 arg1 = reinterpret_cast< wxGrid * >(argp1);
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16532 wxPyEndAllowThreads(__tstate);
16533 if (PyErr_Occurred()) SWIG_fail;
16534 }
16535 resultobj = SWIG_From_int(static_cast< int >(result));
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj = 0;
16544 wxGrid *arg1 = (wxGrid *) 0 ;
16545 wxColour *arg2 = 0 ;
16546 void *argp1 = 0 ;
16547 int res1 = 0 ;
16548 wxColour temp2 ;
16549 PyObject * obj0 = 0 ;
16550 PyObject * obj1 = 0 ;
16551 char * kwnames[] = {
16552 (char *) "self",(char *)"arg2", NULL
16553 };
16554
16555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16557 if (!SWIG_IsOK(res1)) {
16558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16559 }
16560 arg1 = reinterpret_cast< wxGrid * >(argp1);
16561 {
16562 arg2 = &temp2;
16563 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16564 }
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 resultobj = SWIG_Py_Void();
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj = 0;
16580 wxGrid *arg1 = (wxGrid *) 0 ;
16581 int arg2 ;
16582 int arg3 ;
16583 wxColour *arg4 = 0 ;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 int val2 ;
16587 int ecode2 = 0 ;
16588 int val3 ;
16589 int ecode3 = 0 ;
16590 wxColour temp4 ;
16591 PyObject * obj0 = 0 ;
16592 PyObject * obj1 = 0 ;
16593 PyObject * obj2 = 0 ;
16594 PyObject * obj3 = 0 ;
16595 char * kwnames[] = {
16596 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16597 };
16598
16599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16601 if (!SWIG_IsOK(res1)) {
16602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16603 }
16604 arg1 = reinterpret_cast< wxGrid * >(argp1);
16605 ecode2 = SWIG_AsVal_int(obj1, &val2);
16606 if (!SWIG_IsOK(ecode2)) {
16607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16608 }
16609 arg2 = static_cast< int >(val2);
16610 ecode3 = SWIG_AsVal_int(obj2, &val3);
16611 if (!SWIG_IsOK(ecode3)) {
16612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16613 }
16614 arg3 = static_cast< int >(val3);
16615 {
16616 arg4 = &temp4;
16617 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16618 }
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 resultobj = SWIG_Py_Void();
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = 0;
16634 wxGrid *arg1 = (wxGrid *) 0 ;
16635 wxColour *arg2 = 0 ;
16636 void *argp1 = 0 ;
16637 int res1 = 0 ;
16638 wxColour temp2 ;
16639 PyObject * obj0 = 0 ;
16640 PyObject * obj1 = 0 ;
16641 char * kwnames[] = {
16642 (char *) "self",(char *)"arg2", NULL
16643 };
16644
16645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16647 if (!SWIG_IsOK(res1)) {
16648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16649 }
16650 arg1 = reinterpret_cast< wxGrid * >(argp1);
16651 {
16652 arg2 = &temp2;
16653 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16654 }
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 resultobj = SWIG_Py_Void();
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj = 0;
16670 wxGrid *arg1 = (wxGrid *) 0 ;
16671 int arg2 ;
16672 int arg3 ;
16673 wxColour *arg4 = 0 ;
16674 void *argp1 = 0 ;
16675 int res1 = 0 ;
16676 int val2 ;
16677 int ecode2 = 0 ;
16678 int val3 ;
16679 int ecode3 = 0 ;
16680 wxColour temp4 ;
16681 PyObject * obj0 = 0 ;
16682 PyObject * obj1 = 0 ;
16683 PyObject * obj2 = 0 ;
16684 PyObject * obj3 = 0 ;
16685 char * kwnames[] = {
16686 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16687 };
16688
16689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16693 }
16694 arg1 = reinterpret_cast< wxGrid * >(argp1);
16695 ecode2 = SWIG_AsVal_int(obj1, &val2);
16696 if (!SWIG_IsOK(ecode2)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16698 }
16699 arg2 = static_cast< int >(val2);
16700 ecode3 = SWIG_AsVal_int(obj2, &val3);
16701 if (!SWIG_IsOK(ecode3)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16703 }
16704 arg3 = static_cast< int >(val3);
16705 {
16706 arg4 = &temp4;
16707 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16708 }
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxGrid *arg1 = (wxGrid *) 0 ;
16725 wxFont *arg2 = 0 ;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 void *argp2 = 0 ;
16729 int res2 = 0 ;
16730 PyObject * obj0 = 0 ;
16731 PyObject * obj1 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "self",(char *)"arg2", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16738 if (!SWIG_IsOK(res1)) {
16739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16740 }
16741 arg1 = reinterpret_cast< wxGrid * >(argp1);
16742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16743 if (!SWIG_IsOK(res2)) {
16744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16745 }
16746 if (!argp2) {
16747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16748 }
16749 arg2 = reinterpret_cast< wxFont * >(argp2);
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 resultobj = SWIG_Py_Void();
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16764 PyObject *resultobj = 0;
16765 wxGrid *arg1 = (wxGrid *) 0 ;
16766 int arg2 ;
16767 int arg3 ;
16768 wxFont *arg4 = 0 ;
16769 void *argp1 = 0 ;
16770 int res1 = 0 ;
16771 int val2 ;
16772 int ecode2 = 0 ;
16773 int val3 ;
16774 int ecode3 = 0 ;
16775 void *argp4 = 0 ;
16776 int res4 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 PyObject * obj1 = 0 ;
16779 PyObject * obj2 = 0 ;
16780 PyObject * obj3 = 0 ;
16781 char * kwnames[] = {
16782 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16783 };
16784
16785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16787 if (!SWIG_IsOK(res1)) {
16788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16789 }
16790 arg1 = reinterpret_cast< wxGrid * >(argp1);
16791 ecode2 = SWIG_AsVal_int(obj1, &val2);
16792 if (!SWIG_IsOK(ecode2)) {
16793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16794 }
16795 arg2 = static_cast< int >(val2);
16796 ecode3 = SWIG_AsVal_int(obj2, &val3);
16797 if (!SWIG_IsOK(ecode3)) {
16798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16799 }
16800 arg3 = static_cast< int >(val3);
16801 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16802 if (!SWIG_IsOK(res4)) {
16803 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16804 }
16805 if (!argp4) {
16806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16807 }
16808 arg4 = reinterpret_cast< wxFont * >(argp4);
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 resultobj = SWIG_Py_Void();
16816 return resultobj;
16817 fail:
16818 return NULL;
16819 }
16820
16821
16822 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16823 PyObject *resultobj = 0;
16824 wxGrid *arg1 = (wxGrid *) 0 ;
16825 int arg2 ;
16826 int arg3 ;
16827 void *argp1 = 0 ;
16828 int res1 = 0 ;
16829 int val2 ;
16830 int ecode2 = 0 ;
16831 int val3 ;
16832 int ecode3 = 0 ;
16833 PyObject * obj0 = 0 ;
16834 PyObject * obj1 = 0 ;
16835 PyObject * obj2 = 0 ;
16836 char * kwnames[] = {
16837 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16838 };
16839
16840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16842 if (!SWIG_IsOK(res1)) {
16843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16844 }
16845 arg1 = reinterpret_cast< wxGrid * >(argp1);
16846 ecode2 = SWIG_AsVal_int(obj1, &val2);
16847 if (!SWIG_IsOK(ecode2)) {
16848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16849 }
16850 arg2 = static_cast< int >(val2);
16851 ecode3 = SWIG_AsVal_int(obj2, &val3);
16852 if (!SWIG_IsOK(ecode3)) {
16853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16854 }
16855 arg3 = static_cast< int >(val3);
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 resultobj = SWIG_Py_Void();
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj = 0;
16871 wxGrid *arg1 = (wxGrid *) 0 ;
16872 int arg2 ;
16873 int arg3 ;
16874 int arg4 ;
16875 int arg5 ;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 int val2 ;
16879 int ecode2 = 0 ;
16880 int val3 ;
16881 int ecode3 = 0 ;
16882 int val4 ;
16883 int ecode4 = 0 ;
16884 int val5 ;
16885 int ecode5 = 0 ;
16886 PyObject * obj0 = 0 ;
16887 PyObject * obj1 = 0 ;
16888 PyObject * obj2 = 0 ;
16889 PyObject * obj3 = 0 ;
16890 PyObject * obj4 = 0 ;
16891 char * kwnames[] = {
16892 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16893 };
16894
16895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16897 if (!SWIG_IsOK(res1)) {
16898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16899 }
16900 arg1 = reinterpret_cast< wxGrid * >(argp1);
16901 ecode2 = SWIG_AsVal_int(obj1, &val2);
16902 if (!SWIG_IsOK(ecode2)) {
16903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16904 }
16905 arg2 = static_cast< int >(val2);
16906 ecode3 = SWIG_AsVal_int(obj2, &val3);
16907 if (!SWIG_IsOK(ecode3)) {
16908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16909 }
16910 arg3 = static_cast< int >(val3);
16911 ecode4 = SWIG_AsVal_int(obj3, &val4);
16912 if (!SWIG_IsOK(ecode4)) {
16913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16914 }
16915 arg4 = static_cast< int >(val4);
16916 ecode5 = SWIG_AsVal_int(obj4, &val5);
16917 if (!SWIG_IsOK(ecode5)) {
16918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16919 }
16920 arg5 = static_cast< int >(val5);
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 resultobj = SWIG_Py_Void();
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj = 0;
16936 wxGrid *arg1 = (wxGrid *) 0 ;
16937 bool arg2 ;
16938 void *argp1 = 0 ;
16939 int res1 = 0 ;
16940 bool val2 ;
16941 int ecode2 = 0 ;
16942 PyObject * obj0 = 0 ;
16943 PyObject * obj1 = 0 ;
16944 char * kwnames[] = {
16945 (char *) "self",(char *) "allow", NULL
16946 };
16947
16948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16950 if (!SWIG_IsOK(res1)) {
16951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16952 }
16953 arg1 = reinterpret_cast< wxGrid * >(argp1);
16954 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16955 if (!SWIG_IsOK(ecode2)) {
16956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16957 }
16958 arg2 = static_cast< bool >(val2);
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 (arg1)->SetDefaultCellOverflow(arg2);
16962 wxPyEndAllowThreads(__tstate);
16963 if (PyErr_Occurred()) SWIG_fail;
16964 }
16965 resultobj = SWIG_Py_Void();
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16973 PyObject *resultobj = 0;
16974 wxGrid *arg1 = (wxGrid *) 0 ;
16975 int arg2 ;
16976 int arg3 ;
16977 bool arg4 ;
16978 void *argp1 = 0 ;
16979 int res1 = 0 ;
16980 int val2 ;
16981 int ecode2 = 0 ;
16982 int val3 ;
16983 int ecode3 = 0 ;
16984 bool val4 ;
16985 int ecode4 = 0 ;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 PyObject * obj2 = 0 ;
16989 PyObject * obj3 = 0 ;
16990 char * kwnames[] = {
16991 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16992 };
16993
16994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16996 if (!SWIG_IsOK(res1)) {
16997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16998 }
16999 arg1 = reinterpret_cast< wxGrid * >(argp1);
17000 ecode2 = SWIG_AsVal_int(obj1, &val2);
17001 if (!SWIG_IsOK(ecode2)) {
17002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17003 }
17004 arg2 = static_cast< int >(val2);
17005 ecode3 = SWIG_AsVal_int(obj2, &val3);
17006 if (!SWIG_IsOK(ecode3)) {
17007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17008 }
17009 arg3 = static_cast< int >(val3);
17010 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17011 if (!SWIG_IsOK(ecode4)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17013 }
17014 arg4 = static_cast< bool >(val4);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxGrid *arg1 = (wxGrid *) 0 ;
17031 int arg2 ;
17032 int arg3 ;
17033 int arg4 ;
17034 int arg5 ;
17035 void *argp1 = 0 ;
17036 int res1 = 0 ;
17037 int val2 ;
17038 int ecode2 = 0 ;
17039 int val3 ;
17040 int ecode3 = 0 ;
17041 int val4 ;
17042 int ecode4 = 0 ;
17043 int val5 ;
17044 int ecode5 = 0 ;
17045 PyObject * obj0 = 0 ;
17046 PyObject * obj1 = 0 ;
17047 PyObject * obj2 = 0 ;
17048 PyObject * obj3 = 0 ;
17049 PyObject * obj4 = 0 ;
17050 char * kwnames[] = {
17051 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17052 };
17053
17054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17056 if (!SWIG_IsOK(res1)) {
17057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17058 }
17059 arg1 = reinterpret_cast< wxGrid * >(argp1);
17060 ecode2 = SWIG_AsVal_int(obj1, &val2);
17061 if (!SWIG_IsOK(ecode2)) {
17062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17063 }
17064 arg2 = static_cast< int >(val2);
17065 ecode3 = SWIG_AsVal_int(obj2, &val3);
17066 if (!SWIG_IsOK(ecode3)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17068 }
17069 arg3 = static_cast< int >(val3);
17070 ecode4 = SWIG_AsVal_int(obj3, &val4);
17071 if (!SWIG_IsOK(ecode4)) {
17072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17073 }
17074 arg4 = static_cast< int >(val4);
17075 ecode5 = SWIG_AsVal_int(obj4, &val5);
17076 if (!SWIG_IsOK(ecode5)) {
17077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17078 }
17079 arg5 = static_cast< int >(val5);
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 resultobj = SWIG_Py_Void();
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj = 0;
17095 wxGrid *arg1 = (wxGrid *) 0 ;
17096 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17097 void *argp1 = 0 ;
17098 int res1 = 0 ;
17099 void *argp2 = 0 ;
17100 int res2 = 0 ;
17101 PyObject * obj0 = 0 ;
17102 PyObject * obj1 = 0 ;
17103 char * kwnames[] = {
17104 (char *) "self",(char *) "renderer", NULL
17105 };
17106
17107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17109 if (!SWIG_IsOK(res1)) {
17110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17111 }
17112 arg1 = reinterpret_cast< wxGrid * >(argp1);
17113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17114 if (!SWIG_IsOK(res2)) {
17115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17116 }
17117 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 (arg1)->SetDefaultRenderer(arg2);
17121 wxPyEndAllowThreads(__tstate);
17122 if (PyErr_Occurred()) SWIG_fail;
17123 }
17124 resultobj = SWIG_Py_Void();
17125 return resultobj;
17126 fail:
17127 return NULL;
17128 }
17129
17130
17131 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17132 PyObject *resultobj = 0;
17133 wxGrid *arg1 = (wxGrid *) 0 ;
17134 int arg2 ;
17135 int arg3 ;
17136 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17137 void *argp1 = 0 ;
17138 int res1 = 0 ;
17139 int val2 ;
17140 int ecode2 = 0 ;
17141 int val3 ;
17142 int ecode3 = 0 ;
17143 void *argp4 = 0 ;
17144 int res4 = 0 ;
17145 PyObject * obj0 = 0 ;
17146 PyObject * obj1 = 0 ;
17147 PyObject * obj2 = 0 ;
17148 PyObject * obj3 = 0 ;
17149 char * kwnames[] = {
17150 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17151 };
17152
17153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17155 if (!SWIG_IsOK(res1)) {
17156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17157 }
17158 arg1 = reinterpret_cast< wxGrid * >(argp1);
17159 ecode2 = SWIG_AsVal_int(obj1, &val2);
17160 if (!SWIG_IsOK(ecode2)) {
17161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17162 }
17163 arg2 = static_cast< int >(val2);
17164 ecode3 = SWIG_AsVal_int(obj2, &val3);
17165 if (!SWIG_IsOK(ecode3)) {
17166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17167 }
17168 arg3 = static_cast< int >(val3);
17169 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17170 if (!SWIG_IsOK(res4)) {
17171 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17172 }
17173 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17174 {
17175 PyThreadState* __tstate = wxPyBeginAllowThreads();
17176 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17177 wxPyEndAllowThreads(__tstate);
17178 if (PyErr_Occurred()) SWIG_fail;
17179 }
17180 resultobj = SWIG_Py_Void();
17181 return resultobj;
17182 fail:
17183 return NULL;
17184 }
17185
17186
17187 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17188 PyObject *resultobj = 0;
17189 wxGrid *arg1 = (wxGrid *) 0 ;
17190 wxGridCellRenderer *result = 0 ;
17191 void *argp1 = 0 ;
17192 int res1 = 0 ;
17193 PyObject *swig_obj[1] ;
17194
17195 if (!args) SWIG_fail;
17196 swig_obj[0] = args;
17197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17198 if (!SWIG_IsOK(res1)) {
17199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17200 }
17201 arg1 = reinterpret_cast< wxGrid * >(argp1);
17202 {
17203 PyThreadState* __tstate = wxPyBeginAllowThreads();
17204 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 {
17209 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17210 }
17211 return resultobj;
17212 fail:
17213 return NULL;
17214 }
17215
17216
17217 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj = 0;
17219 wxGrid *arg1 = (wxGrid *) 0 ;
17220 int arg2 ;
17221 int arg3 ;
17222 wxGridCellRenderer *result = 0 ;
17223 void *argp1 = 0 ;
17224 int res1 = 0 ;
17225 int val2 ;
17226 int ecode2 = 0 ;
17227 int val3 ;
17228 int ecode3 = 0 ;
17229 PyObject * obj0 = 0 ;
17230 PyObject * obj1 = 0 ;
17231 PyObject * obj2 = 0 ;
17232 char * kwnames[] = {
17233 (char *) "self",(char *) "row",(char *) "col", NULL
17234 };
17235
17236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17238 if (!SWIG_IsOK(res1)) {
17239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17240 }
17241 arg1 = reinterpret_cast< wxGrid * >(argp1);
17242 ecode2 = SWIG_AsVal_int(obj1, &val2);
17243 if (!SWIG_IsOK(ecode2)) {
17244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17245 }
17246 arg2 = static_cast< int >(val2);
17247 ecode3 = SWIG_AsVal_int(obj2, &val3);
17248 if (!SWIG_IsOK(ecode3)) {
17249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17250 }
17251 arg3 = static_cast< int >(val3);
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17255 wxPyEndAllowThreads(__tstate);
17256 if (PyErr_Occurred()) SWIG_fail;
17257 }
17258 {
17259 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17260 }
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj = 0;
17269 wxGrid *arg1 = (wxGrid *) 0 ;
17270 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17271 void *argp1 = 0 ;
17272 int res1 = 0 ;
17273 void *argp2 = 0 ;
17274 int res2 = 0 ;
17275 PyObject * obj0 = 0 ;
17276 PyObject * obj1 = 0 ;
17277 char * kwnames[] = {
17278 (char *) "self",(char *) "editor", NULL
17279 };
17280
17281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17283 if (!SWIG_IsOK(res1)) {
17284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17285 }
17286 arg1 = reinterpret_cast< wxGrid * >(argp1);
17287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17288 if (!SWIG_IsOK(res2)) {
17289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17290 }
17291 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17292 {
17293 PyThreadState* __tstate = wxPyBeginAllowThreads();
17294 (arg1)->SetDefaultEditor(arg2);
17295 wxPyEndAllowThreads(__tstate);
17296 if (PyErr_Occurred()) SWIG_fail;
17297 }
17298 resultobj = SWIG_Py_Void();
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj = 0;
17307 wxGrid *arg1 = (wxGrid *) 0 ;
17308 int arg2 ;
17309 int arg3 ;
17310 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17311 void *argp1 = 0 ;
17312 int res1 = 0 ;
17313 int val2 ;
17314 int ecode2 = 0 ;
17315 int val3 ;
17316 int ecode3 = 0 ;
17317 void *argp4 = 0 ;
17318 int res4 = 0 ;
17319 PyObject * obj0 = 0 ;
17320 PyObject * obj1 = 0 ;
17321 PyObject * obj2 = 0 ;
17322 PyObject * obj3 = 0 ;
17323 char * kwnames[] = {
17324 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17325 };
17326
17327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17329 if (!SWIG_IsOK(res1)) {
17330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17331 }
17332 arg1 = reinterpret_cast< wxGrid * >(argp1);
17333 ecode2 = SWIG_AsVal_int(obj1, &val2);
17334 if (!SWIG_IsOK(ecode2)) {
17335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17336 }
17337 arg2 = static_cast< int >(val2);
17338 ecode3 = SWIG_AsVal_int(obj2, &val3);
17339 if (!SWIG_IsOK(ecode3)) {
17340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17341 }
17342 arg3 = static_cast< int >(val3);
17343 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17344 if (!SWIG_IsOK(res4)) {
17345 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17346 }
17347 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17348 {
17349 PyThreadState* __tstate = wxPyBeginAllowThreads();
17350 (arg1)->SetCellEditor(arg2,arg3,arg4);
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 resultobj = SWIG_Py_Void();
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 PyObject *resultobj = 0;
17363 wxGrid *arg1 = (wxGrid *) 0 ;
17364 wxGridCellEditor *result = 0 ;
17365 void *argp1 = 0 ;
17366 int res1 = 0 ;
17367 PyObject *swig_obj[1] ;
17368
17369 if (!args) SWIG_fail;
17370 swig_obj[0] = args;
17371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17372 if (!SWIG_IsOK(res1)) {
17373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17374 }
17375 arg1 = reinterpret_cast< wxGrid * >(argp1);
17376 {
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 {
17383 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17384 }
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj = 0;
17393 wxGrid *arg1 = (wxGrid *) 0 ;
17394 int arg2 ;
17395 int arg3 ;
17396 wxGridCellEditor *result = 0 ;
17397 void *argp1 = 0 ;
17398 int res1 = 0 ;
17399 int val2 ;
17400 int ecode2 = 0 ;
17401 int val3 ;
17402 int ecode3 = 0 ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 PyObject * obj2 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "self",(char *) "row",(char *) "col", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17412 if (!SWIG_IsOK(res1)) {
17413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17414 }
17415 arg1 = reinterpret_cast< wxGrid * >(argp1);
17416 ecode2 = SWIG_AsVal_int(obj1, &val2);
17417 if (!SWIG_IsOK(ecode2)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17419 }
17420 arg2 = static_cast< int >(val2);
17421 ecode3 = SWIG_AsVal_int(obj2, &val3);
17422 if (!SWIG_IsOK(ecode3)) {
17423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17424 }
17425 arg3 = static_cast< int >(val3);
17426 {
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17429 wxPyEndAllowThreads(__tstate);
17430 if (PyErr_Occurred()) SWIG_fail;
17431 }
17432 {
17433 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17434 }
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17442 PyObject *resultobj = 0;
17443 wxGrid *arg1 = (wxGrid *) 0 ;
17444 int arg2 ;
17445 int arg3 ;
17446 wxString result;
17447 void *argp1 = 0 ;
17448 int res1 = 0 ;
17449 int val2 ;
17450 int ecode2 = 0 ;
17451 int val3 ;
17452 int ecode3 = 0 ;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17455 PyObject * obj2 = 0 ;
17456 char * kwnames[] = {
17457 (char *) "self",(char *) "row",(char *) "col", NULL
17458 };
17459
17460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17462 if (!SWIG_IsOK(res1)) {
17463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17464 }
17465 arg1 = reinterpret_cast< wxGrid * >(argp1);
17466 ecode2 = SWIG_AsVal_int(obj1, &val2);
17467 if (!SWIG_IsOK(ecode2)) {
17468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17469 }
17470 arg2 = static_cast< int >(val2);
17471 ecode3 = SWIG_AsVal_int(obj2, &val3);
17472 if (!SWIG_IsOK(ecode3)) {
17473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17474 }
17475 arg3 = static_cast< int >(val3);
17476 {
17477 PyThreadState* __tstate = wxPyBeginAllowThreads();
17478 result = (arg1)->GetCellValue(arg2,arg3);
17479 wxPyEndAllowThreads(__tstate);
17480 if (PyErr_Occurred()) SWIG_fail;
17481 }
17482 {
17483 #if wxUSE_UNICODE
17484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17485 #else
17486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17487 #endif
17488 }
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj = 0;
17497 wxGrid *arg1 = (wxGrid *) 0 ;
17498 int arg2 ;
17499 int arg3 ;
17500 wxString *arg4 = 0 ;
17501 void *argp1 = 0 ;
17502 int res1 = 0 ;
17503 int val2 ;
17504 int ecode2 = 0 ;
17505 int val3 ;
17506 int ecode3 = 0 ;
17507 bool temp4 = false ;
17508 PyObject * obj0 = 0 ;
17509 PyObject * obj1 = 0 ;
17510 PyObject * obj2 = 0 ;
17511 PyObject * obj3 = 0 ;
17512 char * kwnames[] = {
17513 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17514 };
17515
17516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17518 if (!SWIG_IsOK(res1)) {
17519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17520 }
17521 arg1 = reinterpret_cast< wxGrid * >(argp1);
17522 ecode2 = SWIG_AsVal_int(obj1, &val2);
17523 if (!SWIG_IsOK(ecode2)) {
17524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17525 }
17526 arg2 = static_cast< int >(val2);
17527 ecode3 = SWIG_AsVal_int(obj2, &val3);
17528 if (!SWIG_IsOK(ecode3)) {
17529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17530 }
17531 arg3 = static_cast< int >(val3);
17532 {
17533 arg4 = wxString_in_helper(obj3);
17534 if (arg4 == NULL) SWIG_fail;
17535 temp4 = true;
17536 }
17537 {
17538 PyThreadState* __tstate = wxPyBeginAllowThreads();
17539 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 resultobj = SWIG_Py_Void();
17544 {
17545 if (temp4)
17546 delete arg4;
17547 }
17548 return resultobj;
17549 fail:
17550 {
17551 if (temp4)
17552 delete arg4;
17553 }
17554 return NULL;
17555 }
17556
17557
17558 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj = 0;
17560 wxGrid *arg1 = (wxGrid *) 0 ;
17561 int arg2 ;
17562 int arg3 ;
17563 bool result;
17564 void *argp1 = 0 ;
17565 int res1 = 0 ;
17566 int val2 ;
17567 int ecode2 = 0 ;
17568 int val3 ;
17569 int ecode3 = 0 ;
17570 PyObject * obj0 = 0 ;
17571 PyObject * obj1 = 0 ;
17572 PyObject * obj2 = 0 ;
17573 char * kwnames[] = {
17574 (char *) "self",(char *) "row",(char *) "col", NULL
17575 };
17576
17577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17579 if (!SWIG_IsOK(res1)) {
17580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17581 }
17582 arg1 = reinterpret_cast< wxGrid * >(argp1);
17583 ecode2 = SWIG_AsVal_int(obj1, &val2);
17584 if (!SWIG_IsOK(ecode2)) {
17585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17586 }
17587 arg2 = static_cast< int >(val2);
17588 ecode3 = SWIG_AsVal_int(obj2, &val3);
17589 if (!SWIG_IsOK(ecode3)) {
17590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17591 }
17592 arg3 = static_cast< int >(val3);
17593 {
17594 PyThreadState* __tstate = wxPyBeginAllowThreads();
17595 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17601 }
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj = 0;
17610 wxGrid *arg1 = (wxGrid *) 0 ;
17611 int arg2 ;
17612 int arg3 ;
17613 bool arg4 = (bool) true ;
17614 void *argp1 = 0 ;
17615 int res1 = 0 ;
17616 int val2 ;
17617 int ecode2 = 0 ;
17618 int val3 ;
17619 int ecode3 = 0 ;
17620 bool val4 ;
17621 int ecode4 = 0 ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 PyObject * obj2 = 0 ;
17625 PyObject * obj3 = 0 ;
17626 char * kwnames[] = {
17627 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17628 };
17629
17630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17634 }
17635 arg1 = reinterpret_cast< wxGrid * >(argp1);
17636 ecode2 = SWIG_AsVal_int(obj1, &val2);
17637 if (!SWIG_IsOK(ecode2)) {
17638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17639 }
17640 arg2 = static_cast< int >(val2);
17641 ecode3 = SWIG_AsVal_int(obj2, &val3);
17642 if (!SWIG_IsOK(ecode3)) {
17643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17644 }
17645 arg3 = static_cast< int >(val3);
17646 if (obj3) {
17647 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17648 if (!SWIG_IsOK(ecode4)) {
17649 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17650 }
17651 arg4 = static_cast< bool >(val4);
17652 }
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 (arg1)->SetReadOnly(arg2,arg3,arg4);
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 resultobj = SWIG_Py_Void();
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj = 0;
17668 wxGrid *arg1 = (wxGrid *) 0 ;
17669 int arg2 ;
17670 bool arg3 = (bool) false ;
17671 void *argp1 = 0 ;
17672 int res1 = 0 ;
17673 int val2 ;
17674 int ecode2 = 0 ;
17675 bool val3 ;
17676 int ecode3 = 0 ;
17677 PyObject * obj0 = 0 ;
17678 PyObject * obj1 = 0 ;
17679 PyObject * obj2 = 0 ;
17680 char * kwnames[] = {
17681 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17682 };
17683
17684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17686 if (!SWIG_IsOK(res1)) {
17687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17688 }
17689 arg1 = reinterpret_cast< wxGrid * >(argp1);
17690 ecode2 = SWIG_AsVal_int(obj1, &val2);
17691 if (!SWIG_IsOK(ecode2)) {
17692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17693 }
17694 arg2 = static_cast< int >(val2);
17695 if (obj2) {
17696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17697 if (!SWIG_IsOK(ecode3)) {
17698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17699 }
17700 arg3 = static_cast< bool >(val3);
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 (arg1)->SelectRow(arg2,arg3);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_Py_Void();
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj = 0;
17717 wxGrid *arg1 = (wxGrid *) 0 ;
17718 int arg2 ;
17719 bool arg3 = (bool) false ;
17720 void *argp1 = 0 ;
17721 int res1 = 0 ;
17722 int val2 ;
17723 int ecode2 = 0 ;
17724 bool val3 ;
17725 int ecode3 = 0 ;
17726 PyObject * obj0 = 0 ;
17727 PyObject * obj1 = 0 ;
17728 PyObject * obj2 = 0 ;
17729 char * kwnames[] = {
17730 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17731 };
17732
17733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17735 if (!SWIG_IsOK(res1)) {
17736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17737 }
17738 arg1 = reinterpret_cast< wxGrid * >(argp1);
17739 ecode2 = SWIG_AsVal_int(obj1, &val2);
17740 if (!SWIG_IsOK(ecode2)) {
17741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17742 }
17743 arg2 = static_cast< int >(val2);
17744 if (obj2) {
17745 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17746 if (!SWIG_IsOK(ecode3)) {
17747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17748 }
17749 arg3 = static_cast< bool >(val3);
17750 }
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 (arg1)->SelectCol(arg2,arg3);
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 resultobj = SWIG_Py_Void();
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxGrid *arg1 = (wxGrid *) 0 ;
17767 int arg2 ;
17768 int arg3 ;
17769 int arg4 ;
17770 int arg5 ;
17771 bool arg6 = (bool) false ;
17772 void *argp1 = 0 ;
17773 int res1 = 0 ;
17774 int val2 ;
17775 int ecode2 = 0 ;
17776 int val3 ;
17777 int ecode3 = 0 ;
17778 int val4 ;
17779 int ecode4 = 0 ;
17780 int val5 ;
17781 int ecode5 = 0 ;
17782 bool val6 ;
17783 int ecode6 = 0 ;
17784 PyObject * obj0 = 0 ;
17785 PyObject * obj1 = 0 ;
17786 PyObject * obj2 = 0 ;
17787 PyObject * obj3 = 0 ;
17788 PyObject * obj4 = 0 ;
17789 PyObject * obj5 = 0 ;
17790 char * kwnames[] = {
17791 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17792 };
17793
17794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17796 if (!SWIG_IsOK(res1)) {
17797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17798 }
17799 arg1 = reinterpret_cast< wxGrid * >(argp1);
17800 ecode2 = SWIG_AsVal_int(obj1, &val2);
17801 if (!SWIG_IsOK(ecode2)) {
17802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17803 }
17804 arg2 = static_cast< int >(val2);
17805 ecode3 = SWIG_AsVal_int(obj2, &val3);
17806 if (!SWIG_IsOK(ecode3)) {
17807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17808 }
17809 arg3 = static_cast< int >(val3);
17810 ecode4 = SWIG_AsVal_int(obj3, &val4);
17811 if (!SWIG_IsOK(ecode4)) {
17812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17813 }
17814 arg4 = static_cast< int >(val4);
17815 ecode5 = SWIG_AsVal_int(obj4, &val5);
17816 if (!SWIG_IsOK(ecode5)) {
17817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17818 }
17819 arg5 = static_cast< int >(val5);
17820 if (obj5) {
17821 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17822 if (!SWIG_IsOK(ecode6)) {
17823 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17824 }
17825 arg6 = static_cast< bool >(val6);
17826 }
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 resultobj = SWIG_Py_Void();
17834 return resultobj;
17835 fail:
17836 return NULL;
17837 }
17838
17839
17840 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17841 PyObject *resultobj = 0;
17842 wxGrid *arg1 = (wxGrid *) 0 ;
17843 void *argp1 = 0 ;
17844 int res1 = 0 ;
17845 PyObject *swig_obj[1] ;
17846
17847 if (!args) SWIG_fail;
17848 swig_obj[0] = args;
17849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17850 if (!SWIG_IsOK(res1)) {
17851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17852 }
17853 arg1 = reinterpret_cast< wxGrid * >(argp1);
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 (arg1)->SelectAll();
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 resultobj = SWIG_Py_Void();
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17868 PyObject *resultobj = 0;
17869 wxGrid *arg1 = (wxGrid *) 0 ;
17870 bool result;
17871 void *argp1 = 0 ;
17872 int res1 = 0 ;
17873 PyObject *swig_obj[1] ;
17874
17875 if (!args) SWIG_fail;
17876 swig_obj[0] = args;
17877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17878 if (!SWIG_IsOK(res1)) {
17879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17880 }
17881 arg1 = reinterpret_cast< wxGrid * >(argp1);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (bool)(arg1)->IsSelection();
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17890 }
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17898 PyObject *resultobj = 0;
17899 wxGrid *arg1 = (wxGrid *) 0 ;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 PyObject *swig_obj[1] ;
17903
17904 if (!args) SWIG_fail;
17905 swig_obj[0] = args;
17906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17907 if (!SWIG_IsOK(res1)) {
17908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17909 }
17910 arg1 = reinterpret_cast< wxGrid * >(argp1);
17911 {
17912 PyThreadState* __tstate = wxPyBeginAllowThreads();
17913 (arg1)->ClearSelection();
17914 wxPyEndAllowThreads(__tstate);
17915 if (PyErr_Occurred()) SWIG_fail;
17916 }
17917 resultobj = SWIG_Py_Void();
17918 return resultobj;
17919 fail:
17920 return NULL;
17921 }
17922
17923
17924 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17925 PyObject *resultobj = 0;
17926 wxGrid *arg1 = (wxGrid *) 0 ;
17927 int arg2 ;
17928 int arg3 ;
17929 bool result;
17930 void *argp1 = 0 ;
17931 int res1 = 0 ;
17932 int val2 ;
17933 int ecode2 = 0 ;
17934 int val3 ;
17935 int ecode3 = 0 ;
17936 PyObject * obj0 = 0 ;
17937 PyObject * obj1 = 0 ;
17938 PyObject * obj2 = 0 ;
17939 char * kwnames[] = {
17940 (char *) "self",(char *) "row",(char *) "col", NULL
17941 };
17942
17943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17945 if (!SWIG_IsOK(res1)) {
17946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17947 }
17948 arg1 = reinterpret_cast< wxGrid * >(argp1);
17949 ecode2 = SWIG_AsVal_int(obj1, &val2);
17950 if (!SWIG_IsOK(ecode2)) {
17951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17952 }
17953 arg2 = static_cast< int >(val2);
17954 ecode3 = SWIG_AsVal_int(obj2, &val3);
17955 if (!SWIG_IsOK(ecode3)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17957 }
17958 arg3 = static_cast< int >(val3);
17959 {
17960 PyThreadState* __tstate = wxPyBeginAllowThreads();
17961 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17962 wxPyEndAllowThreads(__tstate);
17963 if (PyErr_Occurred()) SWIG_fail;
17964 }
17965 {
17966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17967 }
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17975 PyObject *resultobj = 0;
17976 wxGrid *arg1 = (wxGrid *) 0 ;
17977 wxGridCellCoordsArray result;
17978 void *argp1 = 0 ;
17979 int res1 = 0 ;
17980 PyObject *swig_obj[1] ;
17981
17982 if (!args) SWIG_fail;
17983 swig_obj[0] = args;
17984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17987 }
17988 arg1 = reinterpret_cast< wxGrid * >(argp1);
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = ((wxGrid const *)arg1)->GetSelectedCells();
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 {
17996 resultobj = wxGridCellCoordsArray_helper(result);
17997 }
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18005 PyObject *resultobj = 0;
18006 wxGrid *arg1 = (wxGrid *) 0 ;
18007 wxGridCellCoordsArray result;
18008 void *argp1 = 0 ;
18009 int res1 = 0 ;
18010 PyObject *swig_obj[1] ;
18011
18012 if (!args) SWIG_fail;
18013 swig_obj[0] = args;
18014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18015 if (!SWIG_IsOK(res1)) {
18016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18017 }
18018 arg1 = reinterpret_cast< wxGrid * >(argp1);
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 {
18026 resultobj = wxGridCellCoordsArray_helper(result);
18027 }
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *resultobj = 0;
18036 wxGrid *arg1 = (wxGrid *) 0 ;
18037 wxGridCellCoordsArray result;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 PyObject *swig_obj[1] ;
18041
18042 if (!args) SWIG_fail;
18043 swig_obj[0] = args;
18044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18045 if (!SWIG_IsOK(res1)) {
18046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18047 }
18048 arg1 = reinterpret_cast< wxGrid * >(argp1);
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 {
18056 resultobj = wxGridCellCoordsArray_helper(result);
18057 }
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 PyObject *resultobj = 0;
18066 wxGrid *arg1 = (wxGrid *) 0 ;
18067 wxArrayInt result;
18068 void *argp1 = 0 ;
18069 int res1 = 0 ;
18070 PyObject *swig_obj[1] ;
18071
18072 if (!args) SWIG_fail;
18073 swig_obj[0] = args;
18074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18075 if (!SWIG_IsOK(res1)) {
18076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18077 }
18078 arg1 = reinterpret_cast< wxGrid * >(argp1);
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = ((wxGrid const *)arg1)->GetSelectedRows();
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = wxArrayInt2PyList_helper(result);
18087 }
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18095 PyObject *resultobj = 0;
18096 wxGrid *arg1 = (wxGrid *) 0 ;
18097 wxArrayInt result;
18098 void *argp1 = 0 ;
18099 int res1 = 0 ;
18100 PyObject *swig_obj[1] ;
18101
18102 if (!args) SWIG_fail;
18103 swig_obj[0] = args;
18104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18105 if (!SWIG_IsOK(res1)) {
18106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18107 }
18108 arg1 = reinterpret_cast< wxGrid * >(argp1);
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 result = ((wxGrid const *)arg1)->GetSelectedCols();
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 {
18116 resultobj = wxArrayInt2PyList_helper(result);
18117 }
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18125 PyObject *resultobj = 0;
18126 wxGrid *arg1 = (wxGrid *) 0 ;
18127 int arg2 ;
18128 void *argp1 = 0 ;
18129 int res1 = 0 ;
18130 int val2 ;
18131 int ecode2 = 0 ;
18132 PyObject * obj0 = 0 ;
18133 PyObject * obj1 = 0 ;
18134 char * kwnames[] = {
18135 (char *) "self",(char *) "row", NULL
18136 };
18137
18138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18140 if (!SWIG_IsOK(res1)) {
18141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18142 }
18143 arg1 = reinterpret_cast< wxGrid * >(argp1);
18144 ecode2 = SWIG_AsVal_int(obj1, &val2);
18145 if (!SWIG_IsOK(ecode2)) {
18146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18147 }
18148 arg2 = static_cast< int >(val2);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->DeselectRow(arg2);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj = 0;
18164 wxGrid *arg1 = (wxGrid *) 0 ;
18165 int arg2 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 int val2 ;
18169 int ecode2 = 0 ;
18170 PyObject * obj0 = 0 ;
18171 PyObject * obj1 = 0 ;
18172 char * kwnames[] = {
18173 (char *) "self",(char *) "col", NULL
18174 };
18175
18176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18180 }
18181 arg1 = reinterpret_cast< wxGrid * >(argp1);
18182 ecode2 = SWIG_AsVal_int(obj1, &val2);
18183 if (!SWIG_IsOK(ecode2)) {
18184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18185 }
18186 arg2 = static_cast< int >(val2);
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 (arg1)->DeselectCol(arg2);
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 resultobj = SWIG_Py_Void();
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18201 PyObject *resultobj = 0;
18202 wxGrid *arg1 = (wxGrid *) 0 ;
18203 int arg2 ;
18204 int arg3 ;
18205 void *argp1 = 0 ;
18206 int res1 = 0 ;
18207 int val2 ;
18208 int ecode2 = 0 ;
18209 int val3 ;
18210 int ecode3 = 0 ;
18211 PyObject * obj0 = 0 ;
18212 PyObject * obj1 = 0 ;
18213 PyObject * obj2 = 0 ;
18214 char * kwnames[] = {
18215 (char *) "self",(char *) "row",(char *) "col", NULL
18216 };
18217
18218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18220 if (!SWIG_IsOK(res1)) {
18221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18222 }
18223 arg1 = reinterpret_cast< wxGrid * >(argp1);
18224 ecode2 = SWIG_AsVal_int(obj1, &val2);
18225 if (!SWIG_IsOK(ecode2)) {
18226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18227 }
18228 arg2 = static_cast< int >(val2);
18229 ecode3 = SWIG_AsVal_int(obj2, &val3);
18230 if (!SWIG_IsOK(ecode3)) {
18231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18232 }
18233 arg3 = static_cast< int >(val3);
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 (arg1)->DeselectCell(arg2,arg3);
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 resultobj = SWIG_Py_Void();
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj = 0;
18249 wxGrid *arg1 = (wxGrid *) 0 ;
18250 wxGridCellCoords *arg2 = 0 ;
18251 wxGridCellCoords *arg3 = 0 ;
18252 wxRect result;
18253 void *argp1 = 0 ;
18254 int res1 = 0 ;
18255 wxGridCellCoords temp2 ;
18256 wxGridCellCoords temp3 ;
18257 PyObject * obj0 = 0 ;
18258 PyObject * obj1 = 0 ;
18259 PyObject * obj2 = 0 ;
18260 char * kwnames[] = {
18261 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18262 };
18263
18264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18266 if (!SWIG_IsOK(res1)) {
18267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18268 }
18269 arg1 = reinterpret_cast< wxGrid * >(argp1);
18270 {
18271 arg2 = &temp2;
18272 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18273 }
18274 {
18275 arg3 = &temp3;
18276 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18277 }
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 PyObject *resultobj = 0;
18293 wxGrid *arg1 = (wxGrid *) 0 ;
18294 wxColour result;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 PyObject *swig_obj[1] ;
18298
18299 if (!args) SWIG_fail;
18300 swig_obj[0] = args;
18301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18304 }
18305 arg1 = reinterpret_cast< wxGrid * >(argp1);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *resultobj = 0;
18321 wxGrid *arg1 = (wxGrid *) 0 ;
18322 wxColour result;
18323 void *argp1 = 0 ;
18324 int res1 = 0 ;
18325 PyObject *swig_obj[1] ;
18326
18327 if (!args) SWIG_fail;
18328 swig_obj[0] = args;
18329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18332 }
18333 arg1 = reinterpret_cast< wxGrid * >(argp1);
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj = 0;
18349 wxGrid *arg1 = (wxGrid *) 0 ;
18350 wxColour *arg2 = 0 ;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 wxColour temp2 ;
18354 PyObject * obj0 = 0 ;
18355 PyObject * obj1 = 0 ;
18356 char * kwnames[] = {
18357 (char *) "self",(char *) "c", NULL
18358 };
18359
18360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18362 if (!SWIG_IsOK(res1)) {
18363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18364 }
18365 arg1 = reinterpret_cast< wxGrid * >(argp1);
18366 {
18367 arg2 = &temp2;
18368 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj = 0;
18385 wxGrid *arg1 = (wxGrid *) 0 ;
18386 wxColour *arg2 = 0 ;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 wxColour temp2 ;
18390 PyObject * obj0 = 0 ;
18391 PyObject * obj1 = 0 ;
18392 char * kwnames[] = {
18393 (char *) "self",(char *) "c", NULL
18394 };
18395
18396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18398 if (!SWIG_IsOK(res1)) {
18399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18400 }
18401 arg1 = reinterpret_cast< wxGrid * >(argp1);
18402 {
18403 arg2 = &temp2;
18404 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 resultobj = SWIG_Py_Void();
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj = 0;
18421 wxGrid *arg1 = (wxGrid *) 0 ;
18422 wxString *arg2 = 0 ;
18423 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18424 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18425 void *argp1 = 0 ;
18426 int res1 = 0 ;
18427 bool temp2 = false ;
18428 void *argp3 = 0 ;
18429 int res3 = 0 ;
18430 void *argp4 = 0 ;
18431 int res4 = 0 ;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 PyObject * obj2 = 0 ;
18435 PyObject * obj3 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18444 }
18445 arg1 = reinterpret_cast< wxGrid * >(argp1);
18446 {
18447 arg2 = wxString_in_helper(obj1);
18448 if (arg2 == NULL) SWIG_fail;
18449 temp2 = true;
18450 }
18451 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18452 if (!SWIG_IsOK(res3)) {
18453 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18454 }
18455 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18456 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18457 if (!SWIG_IsOK(res4)) {
18458 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18459 }
18460 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_Py_Void();
18468 {
18469 if (temp2)
18470 delete arg2;
18471 }
18472 return resultobj;
18473 fail:
18474 {
18475 if (temp2)
18476 delete arg2;
18477 }
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj = 0;
18484 wxGrid *arg1 = (wxGrid *) 0 ;
18485 int arg2 ;
18486 int arg3 ;
18487 wxGridCellEditor *result = 0 ;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 int val2 ;
18491 int ecode2 = 0 ;
18492 int val3 ;
18493 int ecode3 = 0 ;
18494 PyObject * obj0 = 0 ;
18495 PyObject * obj1 = 0 ;
18496 PyObject * obj2 = 0 ;
18497 char * kwnames[] = {
18498 (char *) "self",(char *) "row",(char *) "col", NULL
18499 };
18500
18501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxGrid * >(argp1);
18507 ecode2 = SWIG_AsVal_int(obj1, &val2);
18508 if (!SWIG_IsOK(ecode2)) {
18509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18510 }
18511 arg2 = static_cast< int >(val2);
18512 ecode3 = SWIG_AsVal_int(obj2, &val3);
18513 if (!SWIG_IsOK(ecode3)) {
18514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18515 }
18516 arg3 = static_cast< int >(val3);
18517 {
18518 PyThreadState* __tstate = wxPyBeginAllowThreads();
18519 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 {
18524 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18525 }
18526 return resultobj;
18527 fail:
18528 return NULL;
18529 }
18530
18531
18532 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18533 PyObject *resultobj = 0;
18534 wxGrid *arg1 = (wxGrid *) 0 ;
18535 int arg2 ;
18536 int arg3 ;
18537 wxGridCellRenderer *result = 0 ;
18538 void *argp1 = 0 ;
18539 int res1 = 0 ;
18540 int val2 ;
18541 int ecode2 = 0 ;
18542 int val3 ;
18543 int ecode3 = 0 ;
18544 PyObject * obj0 = 0 ;
18545 PyObject * obj1 = 0 ;
18546 PyObject * obj2 = 0 ;
18547 char * kwnames[] = {
18548 (char *) "self",(char *) "row",(char *) "col", NULL
18549 };
18550
18551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18553 if (!SWIG_IsOK(res1)) {
18554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18555 }
18556 arg1 = reinterpret_cast< wxGrid * >(argp1);
18557 ecode2 = SWIG_AsVal_int(obj1, &val2);
18558 if (!SWIG_IsOK(ecode2)) {
18559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18560 }
18561 arg2 = static_cast< int >(val2);
18562 ecode3 = SWIG_AsVal_int(obj2, &val3);
18563 if (!SWIG_IsOK(ecode3)) {
18564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18565 }
18566 arg3 = static_cast< int >(val3);
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 {
18574 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18575 }
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18583 PyObject *resultobj = 0;
18584 wxGrid *arg1 = (wxGrid *) 0 ;
18585 wxString *arg2 = 0 ;
18586 wxGridCellEditor *result = 0 ;
18587 void *argp1 = 0 ;
18588 int res1 = 0 ;
18589 bool temp2 = false ;
18590 PyObject * obj0 = 0 ;
18591 PyObject * obj1 = 0 ;
18592 char * kwnames[] = {
18593 (char *) "self",(char *) "typeName", NULL
18594 };
18595
18596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18598 if (!SWIG_IsOK(res1)) {
18599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18600 }
18601 arg1 = reinterpret_cast< wxGrid * >(argp1);
18602 {
18603 arg2 = wxString_in_helper(obj1);
18604 if (arg2 == NULL) SWIG_fail;
18605 temp2 = true;
18606 }
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18610 wxPyEndAllowThreads(__tstate);
18611 if (PyErr_Occurred()) SWIG_fail;
18612 }
18613 {
18614 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18615 }
18616 {
18617 if (temp2)
18618 delete arg2;
18619 }
18620 return resultobj;
18621 fail:
18622 {
18623 if (temp2)
18624 delete arg2;
18625 }
18626 return NULL;
18627 }
18628
18629
18630 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj = 0;
18632 wxGrid *arg1 = (wxGrid *) 0 ;
18633 wxString *arg2 = 0 ;
18634 wxGridCellRenderer *result = 0 ;
18635 void *argp1 = 0 ;
18636 int res1 = 0 ;
18637 bool temp2 = false ;
18638 PyObject * obj0 = 0 ;
18639 PyObject * obj1 = 0 ;
18640 char * kwnames[] = {
18641 (char *) "self",(char *) "typeName", NULL
18642 };
18643
18644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18646 if (!SWIG_IsOK(res1)) {
18647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18648 }
18649 arg1 = reinterpret_cast< wxGrid * >(argp1);
18650 {
18651 arg2 = wxString_in_helper(obj1);
18652 if (arg2 == NULL) SWIG_fail;
18653 temp2 = true;
18654 }
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 {
18662 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18663 }
18664 {
18665 if (temp2)
18666 delete arg2;
18667 }
18668 return resultobj;
18669 fail:
18670 {
18671 if (temp2)
18672 delete arg2;
18673 }
18674 return NULL;
18675 }
18676
18677
18678 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj = 0;
18680 wxGrid *arg1 = (wxGrid *) 0 ;
18681 int arg2 ;
18682 int arg3 ;
18683 void *argp1 = 0 ;
18684 int res1 = 0 ;
18685 int val2 ;
18686 int ecode2 = 0 ;
18687 int val3 ;
18688 int ecode3 = 0 ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 PyObject * obj2 = 0 ;
18692 char * kwnames[] = {
18693 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18694 };
18695
18696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18698 if (!SWIG_IsOK(res1)) {
18699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18700 }
18701 arg1 = reinterpret_cast< wxGrid * >(argp1);
18702 ecode2 = SWIG_AsVal_int(obj1, &val2);
18703 if (!SWIG_IsOK(ecode2)) {
18704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18705 }
18706 arg2 = static_cast< int >(val2);
18707 ecode3 = SWIG_AsVal_int(obj2, &val3);
18708 if (!SWIG_IsOK(ecode3)) {
18709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18710 }
18711 arg3 = static_cast< int >(val3);
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 (arg1)->SetMargins(arg2,arg3);
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 resultobj = SWIG_Py_Void();
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18726 PyObject *resultobj = 0;
18727 wxGrid *arg1 = (wxGrid *) 0 ;
18728 wxWindow *result = 0 ;
18729 void *argp1 = 0 ;
18730 int res1 = 0 ;
18731 PyObject *swig_obj[1] ;
18732
18733 if (!args) SWIG_fail;
18734 swig_obj[0] = args;
18735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18736 if (!SWIG_IsOK(res1)) {
18737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18738 }
18739 arg1 = reinterpret_cast< wxGrid * >(argp1);
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (wxWindow *)(arg1)->GetGridWindow();
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 {
18747 resultobj = wxPyMake_wxObject(result, 0);
18748 }
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18756 PyObject *resultobj = 0;
18757 wxGrid *arg1 = (wxGrid *) 0 ;
18758 wxWindow *result = 0 ;
18759 void *argp1 = 0 ;
18760 int res1 = 0 ;
18761 PyObject *swig_obj[1] ;
18762
18763 if (!args) SWIG_fail;
18764 swig_obj[0] = args;
18765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18766 if (!SWIG_IsOK(res1)) {
18767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18768 }
18769 arg1 = reinterpret_cast< wxGrid * >(argp1);
18770 {
18771 PyThreadState* __tstate = wxPyBeginAllowThreads();
18772 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18773 wxPyEndAllowThreads(__tstate);
18774 if (PyErr_Occurred()) SWIG_fail;
18775 }
18776 {
18777 resultobj = wxPyMake_wxObject(result, 0);
18778 }
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18786 PyObject *resultobj = 0;
18787 wxGrid *arg1 = (wxGrid *) 0 ;
18788 wxWindow *result = 0 ;
18789 void *argp1 = 0 ;
18790 int res1 = 0 ;
18791 PyObject *swig_obj[1] ;
18792
18793 if (!args) SWIG_fail;
18794 swig_obj[0] = args;
18795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18796 if (!SWIG_IsOK(res1)) {
18797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18798 }
18799 arg1 = reinterpret_cast< wxGrid * >(argp1);
18800 {
18801 PyThreadState* __tstate = wxPyBeginAllowThreads();
18802 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 {
18807 resultobj = wxPyMake_wxObject(result, 0);
18808 }
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxGrid *arg1 = (wxGrid *) 0 ;
18818 wxWindow *result = 0 ;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18828 }
18829 arg1 = reinterpret_cast< wxGrid * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = wxPyMake_wxObject(result, 0);
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj = 0;
18847 wxGrid *arg1 = (wxGrid *) 0 ;
18848 int arg2 ;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 int val2 ;
18852 int ecode2 = 0 ;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char * kwnames[] = {
18856 (char *) "self",(char *) "x", NULL
18857 };
18858
18859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18861 if (!SWIG_IsOK(res1)) {
18862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18863 }
18864 arg1 = reinterpret_cast< wxGrid * >(argp1);
18865 ecode2 = SWIG_AsVal_int(obj1, &val2);
18866 if (!SWIG_IsOK(ecode2)) {
18867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18868 }
18869 arg2 = static_cast< int >(val2);
18870 {
18871 PyThreadState* __tstate = wxPyBeginAllowThreads();
18872 (arg1)->SetScrollLineX(arg2);
18873 wxPyEndAllowThreads(__tstate);
18874 if (PyErr_Occurred()) SWIG_fail;
18875 }
18876 resultobj = SWIG_Py_Void();
18877 return resultobj;
18878 fail:
18879 return NULL;
18880 }
18881
18882
18883 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj = 0;
18885 wxGrid *arg1 = (wxGrid *) 0 ;
18886 int arg2 ;
18887 void *argp1 = 0 ;
18888 int res1 = 0 ;
18889 int val2 ;
18890 int ecode2 = 0 ;
18891 PyObject * obj0 = 0 ;
18892 PyObject * obj1 = 0 ;
18893 char * kwnames[] = {
18894 (char *) "self",(char *) "y", NULL
18895 };
18896
18897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18899 if (!SWIG_IsOK(res1)) {
18900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18901 }
18902 arg1 = reinterpret_cast< wxGrid * >(argp1);
18903 ecode2 = SWIG_AsVal_int(obj1, &val2);
18904 if (!SWIG_IsOK(ecode2)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18906 }
18907 arg2 = static_cast< int >(val2);
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 (arg1)->SetScrollLineY(arg2);
18911 wxPyEndAllowThreads(__tstate);
18912 if (PyErr_Occurred()) SWIG_fail;
18913 }
18914 resultobj = SWIG_Py_Void();
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18922 PyObject *resultobj = 0;
18923 wxGrid *arg1 = (wxGrid *) 0 ;
18924 int result;
18925 void *argp1 = 0 ;
18926 int res1 = 0 ;
18927 PyObject *swig_obj[1] ;
18928
18929 if (!args) SWIG_fail;
18930 swig_obj[0] = args;
18931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18932 if (!SWIG_IsOK(res1)) {
18933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18934 }
18935 arg1 = reinterpret_cast< wxGrid * >(argp1);
18936 {
18937 PyThreadState* __tstate = wxPyBeginAllowThreads();
18938 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 resultobj = SWIG_From_int(static_cast< int >(result));
18943 return resultobj;
18944 fail:
18945 return NULL;
18946 }
18947
18948
18949 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18950 PyObject *resultobj = 0;
18951 wxGrid *arg1 = (wxGrid *) 0 ;
18952 int result;
18953 void *argp1 = 0 ;
18954 int res1 = 0 ;
18955 PyObject *swig_obj[1] ;
18956
18957 if (!args) SWIG_fail;
18958 swig_obj[0] = args;
18959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18960 if (!SWIG_IsOK(res1)) {
18961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18962 }
18963 arg1 = reinterpret_cast< wxGrid * >(argp1);
18964 {
18965 PyThreadState* __tstate = wxPyBeginAllowThreads();
18966 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 resultobj = SWIG_From_int(static_cast< int >(result));
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj = 0;
18979 wxGrid *arg1 = (wxGrid *) 0 ;
18980 int arg2 ;
18981 int result;
18982 void *argp1 = 0 ;
18983 int res1 = 0 ;
18984 int val2 ;
18985 int ecode2 = 0 ;
18986 PyObject * obj0 = 0 ;
18987 PyObject * obj1 = 0 ;
18988 char * kwnames[] = {
18989 (char *) "self",(char *) "x", NULL
18990 };
18991
18992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18994 if (!SWIG_IsOK(res1)) {
18995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18996 }
18997 arg1 = reinterpret_cast< wxGrid * >(argp1);
18998 ecode2 = SWIG_AsVal_int(obj1, &val2);
18999 if (!SWIG_IsOK(ecode2)) {
19000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
19001 }
19002 arg2 = static_cast< int >(val2);
19003 {
19004 PyThreadState* __tstate = wxPyBeginAllowThreads();
19005 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 resultobj = SWIG_From_int(static_cast< int >(result));
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19017 PyObject *resultobj = 0;
19018 wxGrid *arg1 = (wxGrid *) 0 ;
19019 int arg2 ;
19020 int result;
19021 void *argp1 = 0 ;
19022 int res1 = 0 ;
19023 int val2 ;
19024 int ecode2 = 0 ;
19025 PyObject * obj0 = 0 ;
19026 PyObject * obj1 = 0 ;
19027 char * kwnames[] = {
19028 (char *) "self",(char *) "y", NULL
19029 };
19030
19031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxGrid * >(argp1);
19037 ecode2 = SWIG_AsVal_int(obj1, &val2);
19038 if (!SWIG_IsOK(ecode2)) {
19039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19040 }
19041 arg2 = static_cast< int >(val2);
19042 {
19043 PyThreadState* __tstate = wxPyBeginAllowThreads();
19044 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19045 wxPyEndAllowThreads(__tstate);
19046 if (PyErr_Occurred()) SWIG_fail;
19047 }
19048 resultobj = SWIG_From_int(static_cast< int >(result));
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19056 PyObject *resultobj = 0;
19057 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19058 SwigValueWrapper<wxVisualAttributes > result;
19059 int val1 ;
19060 int ecode1 = 0 ;
19061 PyObject * obj0 = 0 ;
19062 char * kwnames[] = {
19063 (char *) "variant", NULL
19064 };
19065
19066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19067 if (obj0) {
19068 ecode1 = SWIG_AsVal_int(obj0, &val1);
19069 if (!SWIG_IsOK(ecode1)) {
19070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19071 }
19072 arg1 = static_cast< wxWindowVariant >(val1);
19073 }
19074 {
19075 if (!wxPyCheckForApp()) SWIG_fail;
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = wxGrid::GetClassDefaultAttributes(arg1);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19082 return resultobj;
19083 fail:
19084 return NULL;
19085 }
19086
19087
19088 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 PyObject *obj;
19090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19091 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19092 return SWIG_Py_Void();
19093 }
19094
19095 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19096 return SWIG_Python_InitShadowInstance(args);
19097 }
19098
19099 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19100 PyObject *resultobj = 0;
19101 int arg1 ;
19102 wxEventType arg2 ;
19103 wxGrid *arg3 = (wxGrid *) 0 ;
19104 int arg4 = (int) -1 ;
19105 int arg5 = (int) -1 ;
19106 int arg6 = (int) -1 ;
19107 int arg7 = (int) -1 ;
19108 bool arg8 = (bool) true ;
19109 bool arg9 = (bool) false ;
19110 bool arg10 = (bool) false ;
19111 bool arg11 = (bool) false ;
19112 bool arg12 = (bool) false ;
19113 wxGridEvent *result = 0 ;
19114 int val1 ;
19115 int ecode1 = 0 ;
19116 int val2 ;
19117 int ecode2 = 0 ;
19118 void *argp3 = 0 ;
19119 int res3 = 0 ;
19120 int val4 ;
19121 int ecode4 = 0 ;
19122 int val5 ;
19123 int ecode5 = 0 ;
19124 int val6 ;
19125 int ecode6 = 0 ;
19126 int val7 ;
19127 int ecode7 = 0 ;
19128 bool val8 ;
19129 int ecode8 = 0 ;
19130 bool val9 ;
19131 int ecode9 = 0 ;
19132 bool val10 ;
19133 int ecode10 = 0 ;
19134 bool val11 ;
19135 int ecode11 = 0 ;
19136 bool val12 ;
19137 int ecode12 = 0 ;
19138 PyObject * obj0 = 0 ;
19139 PyObject * obj1 = 0 ;
19140 PyObject * obj2 = 0 ;
19141 PyObject * obj3 = 0 ;
19142 PyObject * obj4 = 0 ;
19143 PyObject * obj5 = 0 ;
19144 PyObject * obj6 = 0 ;
19145 PyObject * obj7 = 0 ;
19146 PyObject * obj8 = 0 ;
19147 PyObject * obj9 = 0 ;
19148 PyObject * obj10 = 0 ;
19149 PyObject * obj11 = 0 ;
19150 char * kwnames[] = {
19151 (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
19152 };
19153
19154 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;
19155 ecode1 = SWIG_AsVal_int(obj0, &val1);
19156 if (!SWIG_IsOK(ecode1)) {
19157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19158 }
19159 arg1 = static_cast< int >(val1);
19160 ecode2 = SWIG_AsVal_int(obj1, &val2);
19161 if (!SWIG_IsOK(ecode2)) {
19162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19163 }
19164 arg2 = static_cast< wxEventType >(val2);
19165 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19166 if (!SWIG_IsOK(res3)) {
19167 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19168 }
19169 arg3 = reinterpret_cast< wxGrid * >(argp3);
19170 if (obj3) {
19171 ecode4 = SWIG_AsVal_int(obj3, &val4);
19172 if (!SWIG_IsOK(ecode4)) {
19173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19174 }
19175 arg4 = static_cast< int >(val4);
19176 }
19177 if (obj4) {
19178 ecode5 = SWIG_AsVal_int(obj4, &val5);
19179 if (!SWIG_IsOK(ecode5)) {
19180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19181 }
19182 arg5 = static_cast< int >(val5);
19183 }
19184 if (obj5) {
19185 ecode6 = SWIG_AsVal_int(obj5, &val6);
19186 if (!SWIG_IsOK(ecode6)) {
19187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19188 }
19189 arg6 = static_cast< int >(val6);
19190 }
19191 if (obj6) {
19192 ecode7 = SWIG_AsVal_int(obj6, &val7);
19193 if (!SWIG_IsOK(ecode7)) {
19194 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19195 }
19196 arg7 = static_cast< int >(val7);
19197 }
19198 if (obj7) {
19199 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19200 if (!SWIG_IsOK(ecode8)) {
19201 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19202 }
19203 arg8 = static_cast< bool >(val8);
19204 }
19205 if (obj8) {
19206 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19207 if (!SWIG_IsOK(ecode9)) {
19208 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19209 }
19210 arg9 = static_cast< bool >(val9);
19211 }
19212 if (obj9) {
19213 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19214 if (!SWIG_IsOK(ecode10)) {
19215 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19216 }
19217 arg10 = static_cast< bool >(val10);
19218 }
19219 if (obj10) {
19220 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19221 if (!SWIG_IsOK(ecode11)) {
19222 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19223 }
19224 arg11 = static_cast< bool >(val11);
19225 }
19226 if (obj11) {
19227 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19228 if (!SWIG_IsOK(ecode12)) {
19229 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19230 }
19231 arg12 = static_cast< bool >(val12);
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19247 PyObject *resultobj = 0;
19248 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19249 int result;
19250 void *argp1 = 0 ;
19251 int res1 = 0 ;
19252 PyObject *swig_obj[1] ;
19253
19254 if (!args) SWIG_fail;
19255 swig_obj[0] = args;
19256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19257 if (!SWIG_IsOK(res1)) {
19258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19259 }
19260 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (int)(arg1)->GetRow();
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_From_int(static_cast< int >(result));
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19275 PyObject *resultobj = 0;
19276 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19277 int result;
19278 void *argp1 = 0 ;
19279 int res1 = 0 ;
19280 PyObject *swig_obj[1] ;
19281
19282 if (!args) SWIG_fail;
19283 swig_obj[0] = args;
19284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19285 if (!SWIG_IsOK(res1)) {
19286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19287 }
19288 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (int)(arg1)->GetCol();
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_From_int(static_cast< int >(result));
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19303 PyObject *resultobj = 0;
19304 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19305 wxPoint result;
19306 void *argp1 = 0 ;
19307 int res1 = 0 ;
19308 PyObject *swig_obj[1] ;
19309
19310 if (!args) SWIG_fail;
19311 swig_obj[0] = args;
19312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19313 if (!SWIG_IsOK(res1)) {
19314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19315 }
19316 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (arg1)->GetPosition();
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19324 return resultobj;
19325 fail:
19326 return NULL;
19327 }
19328
19329
19330 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19331 PyObject *resultobj = 0;
19332 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19333 bool result;
19334 void *argp1 = 0 ;
19335 int res1 = 0 ;
19336 PyObject *swig_obj[1] ;
19337
19338 if (!args) SWIG_fail;
19339 swig_obj[0] = args;
19340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19341 if (!SWIG_IsOK(res1)) {
19342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19343 }
19344 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (bool)(arg1)->Selecting();
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 {
19352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19353 }
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19361 PyObject *resultobj = 0;
19362 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19363 bool result;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 PyObject *swig_obj[1] ;
19367
19368 if (!args) SWIG_fail;
19369 swig_obj[0] = args;
19370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19371 if (!SWIG_IsOK(res1)) {
19372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19373 }
19374 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = (bool)(arg1)->ControlDown();
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 {
19382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19383 }
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19391 PyObject *resultobj = 0;
19392 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19393 bool result;
19394 void *argp1 = 0 ;
19395 int res1 = 0 ;
19396 PyObject *swig_obj[1] ;
19397
19398 if (!args) SWIG_fail;
19399 swig_obj[0] = args;
19400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19401 if (!SWIG_IsOK(res1)) {
19402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19403 }
19404 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (bool)(arg1)->MetaDown();
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 {
19412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19413 }
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19421 PyObject *resultobj = 0;
19422 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19423 bool result;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 PyObject *swig_obj[1] ;
19427
19428 if (!args) SWIG_fail;
19429 swig_obj[0] = args;
19430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19433 }
19434 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 result = (bool)(arg1)->ShiftDown();
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 {
19442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19443 }
19444 return resultobj;
19445 fail:
19446 return NULL;
19447 }
19448
19449
19450 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19451 PyObject *resultobj = 0;
19452 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19453 bool result;
19454 void *argp1 = 0 ;
19455 int res1 = 0 ;
19456 PyObject *swig_obj[1] ;
19457
19458 if (!args) SWIG_fail;
19459 swig_obj[0] = args;
19460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19461 if (!SWIG_IsOK(res1)) {
19462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19463 }
19464 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 result = (bool)(arg1)->AltDown();
19468 wxPyEndAllowThreads(__tstate);
19469 if (PyErr_Occurred()) SWIG_fail;
19470 }
19471 {
19472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19473 }
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19481 PyObject *resultobj = 0;
19482 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19483 bool result;
19484 void *argp1 = 0 ;
19485 int res1 = 0 ;
19486 PyObject *swig_obj[1] ;
19487
19488 if (!args) SWIG_fail;
19489 swig_obj[0] = args;
19490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19491 if (!SWIG_IsOK(res1)) {
19492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19493 }
19494 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19495 {
19496 PyThreadState* __tstate = wxPyBeginAllowThreads();
19497 result = (bool)(arg1)->CmdDown();
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 {
19502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19503 }
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19511 PyObject *obj;
19512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19513 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19514 return SWIG_Py_Void();
19515 }
19516
19517 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19518 return SWIG_Python_InitShadowInstance(args);
19519 }
19520
19521 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj = 0;
19523 int arg1 ;
19524 wxEventType arg2 ;
19525 wxGrid *arg3 = (wxGrid *) 0 ;
19526 int arg4 = (int) -1 ;
19527 int arg5 = (int) -1 ;
19528 int arg6 = (int) -1 ;
19529 bool arg7 = (bool) false ;
19530 bool arg8 = (bool) false ;
19531 bool arg9 = (bool) false ;
19532 bool arg10 = (bool) false ;
19533 wxGridSizeEvent *result = 0 ;
19534 int val1 ;
19535 int ecode1 = 0 ;
19536 int val2 ;
19537 int ecode2 = 0 ;
19538 void *argp3 = 0 ;
19539 int res3 = 0 ;
19540 int val4 ;
19541 int ecode4 = 0 ;
19542 int val5 ;
19543 int ecode5 = 0 ;
19544 int val6 ;
19545 int ecode6 = 0 ;
19546 bool val7 ;
19547 int ecode7 = 0 ;
19548 bool val8 ;
19549 int ecode8 = 0 ;
19550 bool val9 ;
19551 int ecode9 = 0 ;
19552 bool val10 ;
19553 int ecode10 = 0 ;
19554 PyObject * obj0 = 0 ;
19555 PyObject * obj1 = 0 ;
19556 PyObject * obj2 = 0 ;
19557 PyObject * obj3 = 0 ;
19558 PyObject * obj4 = 0 ;
19559 PyObject * obj5 = 0 ;
19560 PyObject * obj6 = 0 ;
19561 PyObject * obj7 = 0 ;
19562 PyObject * obj8 = 0 ;
19563 PyObject * obj9 = 0 ;
19564 char * kwnames[] = {
19565 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19566 };
19567
19568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19569 ecode1 = SWIG_AsVal_int(obj0, &val1);
19570 if (!SWIG_IsOK(ecode1)) {
19571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19572 }
19573 arg1 = static_cast< int >(val1);
19574 ecode2 = SWIG_AsVal_int(obj1, &val2);
19575 if (!SWIG_IsOK(ecode2)) {
19576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19577 }
19578 arg2 = static_cast< wxEventType >(val2);
19579 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19580 if (!SWIG_IsOK(res3)) {
19581 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19582 }
19583 arg3 = reinterpret_cast< wxGrid * >(argp3);
19584 if (obj3) {
19585 ecode4 = SWIG_AsVal_int(obj3, &val4);
19586 if (!SWIG_IsOK(ecode4)) {
19587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19588 }
19589 arg4 = static_cast< int >(val4);
19590 }
19591 if (obj4) {
19592 ecode5 = SWIG_AsVal_int(obj4, &val5);
19593 if (!SWIG_IsOK(ecode5)) {
19594 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19595 }
19596 arg5 = static_cast< int >(val5);
19597 }
19598 if (obj5) {
19599 ecode6 = SWIG_AsVal_int(obj5, &val6);
19600 if (!SWIG_IsOK(ecode6)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19602 }
19603 arg6 = static_cast< int >(val6);
19604 }
19605 if (obj6) {
19606 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19607 if (!SWIG_IsOK(ecode7)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19609 }
19610 arg7 = static_cast< bool >(val7);
19611 }
19612 if (obj7) {
19613 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19614 if (!SWIG_IsOK(ecode8)) {
19615 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19616 }
19617 arg8 = static_cast< bool >(val8);
19618 }
19619 if (obj8) {
19620 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19621 if (!SWIG_IsOK(ecode9)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19623 }
19624 arg9 = static_cast< bool >(val9);
19625 }
19626 if (obj9) {
19627 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19628 if (!SWIG_IsOK(ecode10)) {
19629 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19630 }
19631 arg10 = static_cast< bool >(val10);
19632 }
19633 {
19634 PyThreadState* __tstate = wxPyBeginAllowThreads();
19635 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19636 wxPyEndAllowThreads(__tstate);
19637 if (PyErr_Occurred()) SWIG_fail;
19638 }
19639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19640 return resultobj;
19641 fail:
19642 return NULL;
19643 }
19644
19645
19646 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19647 PyObject *resultobj = 0;
19648 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19649 int result;
19650 void *argp1 = 0 ;
19651 int res1 = 0 ;
19652 PyObject *swig_obj[1] ;
19653
19654 if (!args) SWIG_fail;
19655 swig_obj[0] = args;
19656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19657 if (!SWIG_IsOK(res1)) {
19658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19659 }
19660 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19661 {
19662 PyThreadState* __tstate = wxPyBeginAllowThreads();
19663 result = (int)(arg1)->GetRowOrCol();
19664 wxPyEndAllowThreads(__tstate);
19665 if (PyErr_Occurred()) SWIG_fail;
19666 }
19667 resultobj = SWIG_From_int(static_cast< int >(result));
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19675 PyObject *resultobj = 0;
19676 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19677 wxPoint result;
19678 void *argp1 = 0 ;
19679 int res1 = 0 ;
19680 PyObject *swig_obj[1] ;
19681
19682 if (!args) SWIG_fail;
19683 swig_obj[0] = args;
19684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19685 if (!SWIG_IsOK(res1)) {
19686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19687 }
19688 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19689 {
19690 PyThreadState* __tstate = wxPyBeginAllowThreads();
19691 result = (arg1)->GetPosition();
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19703 PyObject *resultobj = 0;
19704 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19705 bool result;
19706 void *argp1 = 0 ;
19707 int res1 = 0 ;
19708 PyObject *swig_obj[1] ;
19709
19710 if (!args) SWIG_fail;
19711 swig_obj[0] = args;
19712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19713 if (!SWIG_IsOK(res1)) {
19714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19715 }
19716 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19717 {
19718 PyThreadState* __tstate = wxPyBeginAllowThreads();
19719 result = (bool)(arg1)->ControlDown();
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 {
19724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19725 }
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 PyObject *resultobj = 0;
19734 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19735 bool result;
19736 void *argp1 = 0 ;
19737 int res1 = 0 ;
19738 PyObject *swig_obj[1] ;
19739
19740 if (!args) SWIG_fail;
19741 swig_obj[0] = args;
19742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19743 if (!SWIG_IsOK(res1)) {
19744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19745 }
19746 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = (bool)(arg1)->MetaDown();
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 {
19754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19755 }
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19763 PyObject *resultobj = 0;
19764 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19765 bool result;
19766 void *argp1 = 0 ;
19767 int res1 = 0 ;
19768 PyObject *swig_obj[1] ;
19769
19770 if (!args) SWIG_fail;
19771 swig_obj[0] = args;
19772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19773 if (!SWIG_IsOK(res1)) {
19774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19775 }
19776 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (bool)(arg1)->ShiftDown();
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 {
19784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19785 }
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793 PyObject *resultobj = 0;
19794 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19795 bool result;
19796 void *argp1 = 0 ;
19797 int res1 = 0 ;
19798 PyObject *swig_obj[1] ;
19799
19800 if (!args) SWIG_fail;
19801 swig_obj[0] = args;
19802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19803 if (!SWIG_IsOK(res1)) {
19804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19805 }
19806 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19807 {
19808 PyThreadState* __tstate = wxPyBeginAllowThreads();
19809 result = (bool)(arg1)->AltDown();
19810 wxPyEndAllowThreads(__tstate);
19811 if (PyErr_Occurred()) SWIG_fail;
19812 }
19813 {
19814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19815 }
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19823 PyObject *resultobj = 0;
19824 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19825 bool result;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 PyObject *swig_obj[1] ;
19829
19830 if (!args) SWIG_fail;
19831 swig_obj[0] = args;
19832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19833 if (!SWIG_IsOK(res1)) {
19834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19835 }
19836 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19837 {
19838 PyThreadState* __tstate = wxPyBeginAllowThreads();
19839 result = (bool)(arg1)->CmdDown();
19840 wxPyEndAllowThreads(__tstate);
19841 if (PyErr_Occurred()) SWIG_fail;
19842 }
19843 {
19844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19845 }
19846 return resultobj;
19847 fail:
19848 return NULL;
19849 }
19850
19851
19852 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 PyObject *obj;
19854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19855 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19856 return SWIG_Py_Void();
19857 }
19858
19859 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19860 return SWIG_Python_InitShadowInstance(args);
19861 }
19862
19863 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj = 0;
19865 int arg1 ;
19866 wxEventType arg2 ;
19867 wxGrid *arg3 = (wxGrid *) 0 ;
19868 wxGridCellCoords *arg4 = 0 ;
19869 wxGridCellCoords *arg5 = 0 ;
19870 bool arg6 = (bool) true ;
19871 bool arg7 = (bool) false ;
19872 bool arg8 = (bool) false ;
19873 bool arg9 = (bool) false ;
19874 bool arg10 = (bool) false ;
19875 wxGridRangeSelectEvent *result = 0 ;
19876 int val1 ;
19877 int ecode1 = 0 ;
19878 int val2 ;
19879 int ecode2 = 0 ;
19880 void *argp3 = 0 ;
19881 int res3 = 0 ;
19882 wxGridCellCoords temp4 ;
19883 wxGridCellCoords temp5 ;
19884 bool val6 ;
19885 int ecode6 = 0 ;
19886 bool val7 ;
19887 int ecode7 = 0 ;
19888 bool val8 ;
19889 int ecode8 = 0 ;
19890 bool val9 ;
19891 int ecode9 = 0 ;
19892 bool val10 ;
19893 int ecode10 = 0 ;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 PyObject * obj2 = 0 ;
19897 PyObject * obj3 = 0 ;
19898 PyObject * obj4 = 0 ;
19899 PyObject * obj5 = 0 ;
19900 PyObject * obj6 = 0 ;
19901 PyObject * obj7 = 0 ;
19902 PyObject * obj8 = 0 ;
19903 PyObject * obj9 = 0 ;
19904 char * kwnames[] = {
19905 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19906 };
19907
19908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19909 ecode1 = SWIG_AsVal_int(obj0, &val1);
19910 if (!SWIG_IsOK(ecode1)) {
19911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19912 }
19913 arg1 = static_cast< int >(val1);
19914 ecode2 = SWIG_AsVal_int(obj1, &val2);
19915 if (!SWIG_IsOK(ecode2)) {
19916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19917 }
19918 arg2 = static_cast< wxEventType >(val2);
19919 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19920 if (!SWIG_IsOK(res3)) {
19921 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19922 }
19923 arg3 = reinterpret_cast< wxGrid * >(argp3);
19924 {
19925 arg4 = &temp4;
19926 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19927 }
19928 {
19929 arg5 = &temp5;
19930 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19931 }
19932 if (obj5) {
19933 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19934 if (!SWIG_IsOK(ecode6)) {
19935 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19936 }
19937 arg6 = static_cast< bool >(val6);
19938 }
19939 if (obj6) {
19940 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19941 if (!SWIG_IsOK(ecode7)) {
19942 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19943 }
19944 arg7 = static_cast< bool >(val7);
19945 }
19946 if (obj7) {
19947 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19948 if (!SWIG_IsOK(ecode8)) {
19949 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19950 }
19951 arg8 = static_cast< bool >(val8);
19952 }
19953 if (obj8) {
19954 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19955 if (!SWIG_IsOK(ecode9)) {
19956 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19957 }
19958 arg9 = static_cast< bool >(val9);
19959 }
19960 if (obj9) {
19961 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19962 if (!SWIG_IsOK(ecode10)) {
19963 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19964 }
19965 arg10 = static_cast< bool >(val10);
19966 }
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19981 PyObject *resultobj = 0;
19982 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19983 wxGridCellCoords result;
19984 void *argp1 = 0 ;
19985 int res1 = 0 ;
19986 PyObject *swig_obj[1] ;
19987
19988 if (!args) SWIG_fail;
19989 swig_obj[0] = args;
19990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19991 if (!SWIG_IsOK(res1)) {
19992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19993 }
19994 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19995 {
19996 PyThreadState* __tstate = wxPyBeginAllowThreads();
19997 result = (arg1)->GetTopLeftCoords();
19998 wxPyEndAllowThreads(__tstate);
19999 if (PyErr_Occurred()) SWIG_fail;
20000 }
20001 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20002 return resultobj;
20003 fail:
20004 return NULL;
20005 }
20006
20007
20008 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20009 PyObject *resultobj = 0;
20010 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20011 wxGridCellCoords result;
20012 void *argp1 = 0 ;
20013 int res1 = 0 ;
20014 PyObject *swig_obj[1] ;
20015
20016 if (!args) SWIG_fail;
20017 swig_obj[0] = args;
20018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20019 if (!SWIG_IsOK(res1)) {
20020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20021 }
20022 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 result = (arg1)->GetBottomRightCoords();
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20037 PyObject *resultobj = 0;
20038 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20039 int result;
20040 void *argp1 = 0 ;
20041 int res1 = 0 ;
20042 PyObject *swig_obj[1] ;
20043
20044 if (!args) SWIG_fail;
20045 swig_obj[0] = args;
20046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20047 if (!SWIG_IsOK(res1)) {
20048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20049 }
20050 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20051 {
20052 PyThreadState* __tstate = wxPyBeginAllowThreads();
20053 result = (int)(arg1)->GetTopRow();
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 resultobj = SWIG_From_int(static_cast< int >(result));
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20065 PyObject *resultobj = 0;
20066 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20067 int result;
20068 void *argp1 = 0 ;
20069 int res1 = 0 ;
20070 PyObject *swig_obj[1] ;
20071
20072 if (!args) SWIG_fail;
20073 swig_obj[0] = args;
20074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20075 if (!SWIG_IsOK(res1)) {
20076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20077 }
20078 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (int)(arg1)->GetBottomRow();
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 resultobj = SWIG_From_int(static_cast< int >(result));
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 PyObject *resultobj = 0;
20094 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20095 int result;
20096 void *argp1 = 0 ;
20097 int res1 = 0 ;
20098 PyObject *swig_obj[1] ;
20099
20100 if (!args) SWIG_fail;
20101 swig_obj[0] = args;
20102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20103 if (!SWIG_IsOK(res1)) {
20104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20105 }
20106 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (int)(arg1)->GetLeftCol();
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 resultobj = SWIG_From_int(static_cast< int >(result));
20114 return resultobj;
20115 fail:
20116 return NULL;
20117 }
20118
20119
20120 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20121 PyObject *resultobj = 0;
20122 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20123 int result;
20124 void *argp1 = 0 ;
20125 int res1 = 0 ;
20126 PyObject *swig_obj[1] ;
20127
20128 if (!args) SWIG_fail;
20129 swig_obj[0] = args;
20130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20131 if (!SWIG_IsOK(res1)) {
20132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20133 }
20134 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20135 {
20136 PyThreadState* __tstate = wxPyBeginAllowThreads();
20137 result = (int)(arg1)->GetRightCol();
20138 wxPyEndAllowThreads(__tstate);
20139 if (PyErr_Occurred()) SWIG_fail;
20140 }
20141 resultobj = SWIG_From_int(static_cast< int >(result));
20142 return resultobj;
20143 fail:
20144 return NULL;
20145 }
20146
20147
20148 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20149 PyObject *resultobj = 0;
20150 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20151 bool result;
20152 void *argp1 = 0 ;
20153 int res1 = 0 ;
20154 PyObject *swig_obj[1] ;
20155
20156 if (!args) SWIG_fail;
20157 swig_obj[0] = args;
20158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20159 if (!SWIG_IsOK(res1)) {
20160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20161 }
20162 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (bool)(arg1)->Selecting();
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 {
20170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20171 }
20172 return resultobj;
20173 fail:
20174 return NULL;
20175 }
20176
20177
20178 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20179 PyObject *resultobj = 0;
20180 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20181 bool result;
20182 void *argp1 = 0 ;
20183 int res1 = 0 ;
20184 PyObject *swig_obj[1] ;
20185
20186 if (!args) SWIG_fail;
20187 swig_obj[0] = args;
20188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20189 if (!SWIG_IsOK(res1)) {
20190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20191 }
20192 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20193 {
20194 PyThreadState* __tstate = wxPyBeginAllowThreads();
20195 result = (bool)(arg1)->ControlDown();
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 {
20200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20201 }
20202 return resultobj;
20203 fail:
20204 return NULL;
20205 }
20206
20207
20208 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20209 PyObject *resultobj = 0;
20210 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20211 bool result;
20212 void *argp1 = 0 ;
20213 int res1 = 0 ;
20214 PyObject *swig_obj[1] ;
20215
20216 if (!args) SWIG_fail;
20217 swig_obj[0] = args;
20218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20219 if (!SWIG_IsOK(res1)) {
20220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20221 }
20222 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 result = (bool)(arg1)->MetaDown();
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 {
20230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20231 }
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20239 PyObject *resultobj = 0;
20240 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20241 bool result;
20242 void *argp1 = 0 ;
20243 int res1 = 0 ;
20244 PyObject *swig_obj[1] ;
20245
20246 if (!args) SWIG_fail;
20247 swig_obj[0] = args;
20248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20249 if (!SWIG_IsOK(res1)) {
20250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20251 }
20252 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 result = (bool)(arg1)->ShiftDown();
20256 wxPyEndAllowThreads(__tstate);
20257 if (PyErr_Occurred()) SWIG_fail;
20258 }
20259 {
20260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20261 }
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20269 PyObject *resultobj = 0;
20270 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20271 bool result;
20272 void *argp1 = 0 ;
20273 int res1 = 0 ;
20274 PyObject *swig_obj[1] ;
20275
20276 if (!args) SWIG_fail;
20277 swig_obj[0] = args;
20278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20279 if (!SWIG_IsOK(res1)) {
20280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20281 }
20282 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20283 {
20284 PyThreadState* __tstate = wxPyBeginAllowThreads();
20285 result = (bool)(arg1)->AltDown();
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 {
20290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20291 }
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 PyObject *resultobj = 0;
20300 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20301 bool result;
20302 void *argp1 = 0 ;
20303 int res1 = 0 ;
20304 PyObject *swig_obj[1] ;
20305
20306 if (!args) SWIG_fail;
20307 swig_obj[0] = args;
20308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20309 if (!SWIG_IsOK(res1)) {
20310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20311 }
20312 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (bool)(arg1)->CmdDown();
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 {
20320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20321 }
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 PyObject *obj;
20330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20331 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20332 return SWIG_Py_Void();
20333 }
20334
20335 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20336 return SWIG_Python_InitShadowInstance(args);
20337 }
20338
20339 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj = 0;
20341 int arg1 ;
20342 wxEventType arg2 ;
20343 wxObject *arg3 = (wxObject *) 0 ;
20344 int arg4 ;
20345 int arg5 ;
20346 wxControl *arg6 = (wxControl *) 0 ;
20347 wxGridEditorCreatedEvent *result = 0 ;
20348 int val1 ;
20349 int ecode1 = 0 ;
20350 int val2 ;
20351 int ecode2 = 0 ;
20352 void *argp3 = 0 ;
20353 int res3 = 0 ;
20354 int val4 ;
20355 int ecode4 = 0 ;
20356 int val5 ;
20357 int ecode5 = 0 ;
20358 void *argp6 = 0 ;
20359 int res6 = 0 ;
20360 PyObject * obj0 = 0 ;
20361 PyObject * obj1 = 0 ;
20362 PyObject * obj2 = 0 ;
20363 PyObject * obj3 = 0 ;
20364 PyObject * obj4 = 0 ;
20365 PyObject * obj5 = 0 ;
20366 char * kwnames[] = {
20367 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20368 };
20369
20370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20371 ecode1 = SWIG_AsVal_int(obj0, &val1);
20372 if (!SWIG_IsOK(ecode1)) {
20373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20374 }
20375 arg1 = static_cast< int >(val1);
20376 ecode2 = SWIG_AsVal_int(obj1, &val2);
20377 if (!SWIG_IsOK(ecode2)) {
20378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20379 }
20380 arg2 = static_cast< wxEventType >(val2);
20381 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20382 if (!SWIG_IsOK(res3)) {
20383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20384 }
20385 arg3 = reinterpret_cast< wxObject * >(argp3);
20386 ecode4 = SWIG_AsVal_int(obj3, &val4);
20387 if (!SWIG_IsOK(ecode4)) {
20388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20389 }
20390 arg4 = static_cast< int >(val4);
20391 ecode5 = SWIG_AsVal_int(obj4, &val5);
20392 if (!SWIG_IsOK(ecode5)) {
20393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20394 }
20395 arg5 = static_cast< int >(val5);
20396 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20397 if (!SWIG_IsOK(res6)) {
20398 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20399 }
20400 arg6 = reinterpret_cast< wxControl * >(argp6);
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 PyObject *resultobj = 0;
20416 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20417 int result;
20418 void *argp1 = 0 ;
20419 int res1 = 0 ;
20420 PyObject *swig_obj[1] ;
20421
20422 if (!args) SWIG_fail;
20423 swig_obj[0] = args;
20424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20427 }
20428 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (int)(arg1)->GetRow();
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 resultobj = SWIG_From_int(static_cast< int >(result));
20436 return resultobj;
20437 fail:
20438 return NULL;
20439 }
20440
20441
20442 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20443 PyObject *resultobj = 0;
20444 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20445 int result;
20446 void *argp1 = 0 ;
20447 int res1 = 0 ;
20448 PyObject *swig_obj[1] ;
20449
20450 if (!args) SWIG_fail;
20451 swig_obj[0] = args;
20452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20453 if (!SWIG_IsOK(res1)) {
20454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20455 }
20456 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20457 {
20458 PyThreadState* __tstate = wxPyBeginAllowThreads();
20459 result = (int)(arg1)->GetCol();
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 resultobj = SWIG_From_int(static_cast< int >(result));
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 PyObject *resultobj = 0;
20472 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20473 wxControl *result = 0 ;
20474 void *argp1 = 0 ;
20475 int res1 = 0 ;
20476 PyObject *swig_obj[1] ;
20477
20478 if (!args) SWIG_fail;
20479 swig_obj[0] = args;
20480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20481 if (!SWIG_IsOK(res1)) {
20482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20483 }
20484 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 result = (wxControl *)(arg1)->GetControl();
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 {
20492 resultobj = wxPyMake_wxObject(result, 0);
20493 }
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj = 0;
20502 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20503 int arg2 ;
20504 void *argp1 = 0 ;
20505 int res1 = 0 ;
20506 int val2 ;
20507 int ecode2 = 0 ;
20508 PyObject * obj0 = 0 ;
20509 PyObject * obj1 = 0 ;
20510 char * kwnames[] = {
20511 (char *) "self",(char *) "row", NULL
20512 };
20513
20514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20518 }
20519 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20520 ecode2 = SWIG_AsVal_int(obj1, &val2);
20521 if (!SWIG_IsOK(ecode2)) {
20522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20523 }
20524 arg2 = static_cast< int >(val2);
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 (arg1)->SetRow(arg2);
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_Py_Void();
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20541 int arg2 ;
20542 void *argp1 = 0 ;
20543 int res1 = 0 ;
20544 int val2 ;
20545 int ecode2 = 0 ;
20546 PyObject * obj0 = 0 ;
20547 PyObject * obj1 = 0 ;
20548 char * kwnames[] = {
20549 (char *) "self",(char *) "col", NULL
20550 };
20551
20552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20556 }
20557 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20558 ecode2 = SWIG_AsVal_int(obj1, &val2);
20559 if (!SWIG_IsOK(ecode2)) {
20560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20561 }
20562 arg2 = static_cast< int >(val2);
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 (arg1)->SetCol(arg2);
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 resultobj = SWIG_Py_Void();
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20577 PyObject *resultobj = 0;
20578 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20579 wxControl *arg2 = (wxControl *) 0 ;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 void *argp2 = 0 ;
20583 int res2 = 0 ;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 char * kwnames[] = {
20587 (char *) "self",(char *) "ctrl", NULL
20588 };
20589
20590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20594 }
20595 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20597 if (!SWIG_IsOK(res2)) {
20598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20599 }
20600 arg2 = reinterpret_cast< wxControl * >(argp2);
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 (arg1)->SetControl(arg2);
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 resultobj = SWIG_Py_Void();
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20615 PyObject *obj;
20616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20617 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20618 return SWIG_Py_Void();
20619 }
20620
20621 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20622 return SWIG_Python_InitShadowInstance(args);
20623 }
20624
20625 static PyMethodDef SwigMethods[] = {
20626 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20628 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20630 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20631 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20632 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20635 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20636 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20637 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20640 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20641 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20642 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20643 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20644 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20645 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20646 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20647 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20649 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20651 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20653 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20654 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20655 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20656 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20657 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20659 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20660 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20662 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20663 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20664 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20665 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20666 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20667 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20668 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20670 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20675 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20676 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20682 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20684 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20685 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20686 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20689 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20690 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20691 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20692 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20693 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20694 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20696 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20697 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20699 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20700 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20701 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20704 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20705 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20707 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20708 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20710 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20711 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20712 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20713 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20714 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20717 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20718 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20720 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20721 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20732 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20733 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20734 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20735 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20736 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20737 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20738 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20739 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20740 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20741 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20742 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20743 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20744 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20745 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20748 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20749 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20751 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20752 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20753 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20761 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20762 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20763 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20769 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20770 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20771 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20774 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20776 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20777 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20778 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20791 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20802 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20807 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20808 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20810 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20811 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20812 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20814 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20815 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20817 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20819 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20821 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20823 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20825 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20826 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20827 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20829 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20830 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20832 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20837 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20838 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20839 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20841 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20845 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20846 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20847 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20849 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20851 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20861 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20862 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20863 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20864 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20865 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20868 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20869 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20870 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20871 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20872 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20873 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20874 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20875 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20882 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20883 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20891 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20892 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20897 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20898 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20899 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20900 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20901 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20902 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20903 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20904 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20905 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20906 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20909 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20910 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20913 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20914 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20915 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20931 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20932 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20934 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20935 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20937 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20938 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20940 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20941 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20943 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20944 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20954 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20955 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20957 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20959 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20961 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20963 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20965 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20967 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20981 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20988 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20989 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21003 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21007 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21016 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21017 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21018 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21020 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21021 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21022 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21023 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21024 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21029 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21030 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21039 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21040 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21041 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21042 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21045 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21046 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21050 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21051 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21053 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21054 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21055 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21056 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21057 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21058 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21059 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21060 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21061 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21062 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21063 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21065 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21066 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21067 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21068 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21069 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21070 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21071 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21072 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21073 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21075 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21076 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21077 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21078 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21079 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21080 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21081 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21082 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21083 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21084 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21085 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21086 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21087 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21088 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21090 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21091 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21092 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21096 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21097 { NULL, NULL, 0, NULL }
21098 };
21099
21100
21101 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21102
21103 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21104 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21105 }
21106 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21107 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21108 }
21109 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21110 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21111 }
21112 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21113 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21114 }
21115 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21116 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21117 }
21118 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21119 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21120 }
21121 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21122 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21123 }
21124 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21125 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21126 }
21127 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21128 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21129 }
21130 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21131 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21132 }
21133 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21134 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21135 }
21136 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21137 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21138 }
21139 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21140 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21141 }
21142 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21143 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21144 }
21145 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21146 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21147 }
21148 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21149 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21150 }
21151 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21152 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21153 }
21154 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21155 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21156 }
21157 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21158 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21159 }
21160 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21161 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21162 }
21163 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21164 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21165 }
21166 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21167 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21168 }
21169 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21170 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21171 }
21172 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21173 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21174 }
21175 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21176 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21177 }
21178 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21179 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21180 }
21181 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21182 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21183 }
21184 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21185 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21186 }
21187 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21188 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21189 }
21190 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21191 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21192 }
21193 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21194 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21195 }
21196 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21197 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21198 }
21199 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21200 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21201 }
21202 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21203 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21204 }
21205 static void *_p_wxGridTo_p_wxPanel(void *x) {
21206 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21207 }
21208 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21209 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21210 }
21211 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21212 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21213 }
21214 static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
21215 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21216 }
21217 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21218 return (void *)((wxPanel *) ((wxPyPanel *) x));
21219 }
21220 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21221 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21222 }
21223 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21224 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21225 }
21226 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21227 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21228 }
21229 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21230 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21231 }
21232 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21233 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21234 }
21235 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21236 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21237 }
21238 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21239 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21240 }
21241 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21242 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21243 }
21244 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21245 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21246 }
21247 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21248 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21249 }
21250 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21251 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21252 }
21253 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21254 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21255 }
21256 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21257 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21258 }
21259 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21260 return (void *)((wxWindow *) ((wxMenuBar *) x));
21261 }
21262 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21263 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21264 }
21265 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21266 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21267 }
21268 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21269 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21270 }
21271 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21272 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21273 }
21274 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21275 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21276 }
21277 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21278 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21279 }
21280 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21281 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21282 }
21283 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21284 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21285 }
21286 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21287 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21288 }
21289 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21290 return (void *)((wxWindow *) ((wxPanel *) x));
21291 }
21292 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21293 return (void *)((wxWindow *) ((wxStatusBar *) x));
21294 }
21295 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21296 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21297 }
21298 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21299 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21300 }
21301 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21302 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21303 }
21304 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21305 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21306 }
21307 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21308 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21309 }
21310 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21311 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21312 }
21313 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21314 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21315 }
21316 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21317 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21318 }
21319 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21320 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21321 }
21322 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21323 return (void *)((wxWindow *) ((wxSashWindow *) x));
21324 }
21325 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21326 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21327 }
21328 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21329 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21330 }
21331 static void *_p_wxControlTo_p_wxWindow(void *x) {
21332 return (void *)((wxWindow *) ((wxControl *) x));
21333 }
21334 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21335 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21336 }
21337 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21338 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21339 }
21340 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21341 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21342 }
21343 static void *_p_wxGridTo_p_wxWindow(void *x) {
21344 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21345 }
21346 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21347 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21348 }
21349 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21350 return (void *)((wxWindow *) ((wxPyWindow *) x));
21351 }
21352 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21353 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21354 }
21355 static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
21356 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21357 }
21358 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21359 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21360 }
21361 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21362 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21363 }
21364 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21365 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21366 }
21367 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21368 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21369 }
21370 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21371 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21372 }
21373 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21374 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21375 }
21376 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21377 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21378 }
21379 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21380 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21381 }
21382 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21383 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21384 }
21385 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21386 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21387 }
21388 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21389 return (void *)((wxControl *) ((wxControlWithItems *) x));
21390 }
21391 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21392 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21393 }
21394 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21395 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21396 }
21397 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21398 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21399 }
21400 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21401 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21402 }
21403 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21404 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21405 }
21406 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21407 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21408 }
21409 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21410 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21411 }
21412 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21413 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21414 }
21415 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21416 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21417 }
21418 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21419 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21420 }
21421 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21422 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21423 }
21424 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21425 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21426 }
21427 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21428 return (void *)((wxEvent *) ((wxPyEvent *) x));
21429 }
21430 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21431 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21432 }
21433 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21434 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21435 }
21436 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21437 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21438 }
21439 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21440 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21441 }
21442 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21443 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21444 }
21445 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21446 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21447 }
21448 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21449 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21450 }
21451 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21452 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21453 }
21454 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21455 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21456 }
21457 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21458 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21459 }
21460 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21461 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21462 }
21463 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21464 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21465 }
21466 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21467 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21468 }
21469 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21470 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21471 }
21472 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21473 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21474 }
21475 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21476 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21477 }
21478 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21479 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21480 }
21481 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21482 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21483 }
21484 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21485 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21486 }
21487 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21488 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21489 }
21490 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21491 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21492 }
21493 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21494 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21495 }
21496 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21497 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21498 }
21499 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21500 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21501 }
21502 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21503 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21504 }
21505 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21506 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21507 }
21508 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21509 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21510 }
21511 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21512 return (void *)((wxEvent *) ((wxShowEvent *) x));
21513 }
21514 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21515 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21516 }
21517 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21518 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21519 }
21520 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21521 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21522 }
21523 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21524 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21525 }
21526 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21527 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21528 }
21529 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21530 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21531 }
21532 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21533 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21534 }
21535 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21536 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21537 }
21538 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21539 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21540 }
21541 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
21542 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
21543 }
21544 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21545 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21546 }
21547 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21548 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21549 }
21550 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21551 return (void *)((wxObject *) ((wxSizerItem *) x));
21552 }
21553 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21554 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21555 }
21556 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21558 }
21559 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21560 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21561 }
21562 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21563 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21564 }
21565 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21566 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21567 }
21568 static void *_p_wxSizerTo_p_wxObject(void *x) {
21569 return (void *)((wxObject *) ((wxSizer *) x));
21570 }
21571 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21572 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21573 }
21574 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21576 }
21577 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21578 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21579 }
21580 static void *_p_wxEventTo_p_wxObject(void *x) {
21581 return (void *)((wxObject *) ((wxEvent *) x));
21582 }
21583 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21584 return (void *)((wxObject *) ((wxFontData *) x));
21585 }
21586 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21587 return (void *)((wxObject *) ((wxPrintData *) x));
21588 }
21589 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21590 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21591 }
21592 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21593 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21594 }
21595 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21596 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21597 }
21598 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21599 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21600 }
21601 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21602 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21603 }
21604 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21605 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21606 }
21607 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21608 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21609 }
21610 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21611 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21612 }
21613 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21614 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21615 }
21616 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21617 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21618 }
21619 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21620 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21621 }
21622 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21623 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21624 }
21625 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21626 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21627 }
21628 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21629 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21630 }
21631 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21632 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21633 }
21634 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21636 }
21637 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21638 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21639 }
21640 static void *_p_wxControlTo_p_wxObject(void *x) {
21641 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21642 }
21643 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21644 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21645 }
21646 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21647 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21648 }
21649 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21650 return (void *)((wxObject *) ((wxFSFile *) x));
21651 }
21652 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21653 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21654 }
21655 static void *_p_wxGridTo_p_wxObject(void *x) {
21656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21657 }
21658 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21659 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21660 }
21661 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21662 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21663 }
21664 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21665 return (void *)((wxObject *) ((wxColourData *) x));
21666 }
21667 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21668 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21669 }
21670 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21671 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21672 }
21673 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21675 }
21676 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21677 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21678 }
21679 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21680 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21681 }
21682 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21684 }
21685 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21686 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21687 }
21688 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21689 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21690 }
21691 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21692 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21693 }
21694 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21695 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21696 }
21697 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21698 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21699 }
21700 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21701 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21702 }
21703 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21704 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21705 }
21706 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21707 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21708 }
21709 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21710 return (void *)((wxObject *) ((wxPrinter *) x));
21711 }
21712 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21713 return (void *)((wxObject *) ((wxMenuItem *) x));
21714 }
21715 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21717 }
21718 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21719 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21720 }
21721 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21722 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21723 }
21724 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21725 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21726 }
21727 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21728 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21729 }
21730 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21731 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21732 }
21733 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21734 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21735 }
21736 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21737 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21738 }
21739 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21740 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21741 }
21742 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21743 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21744 }
21745 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21746 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21747 }
21748 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21749 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21750 }
21751 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21752 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21753 }
21754 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21755 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21756 }
21757 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21758 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21759 }
21760 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21761 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21762 }
21763 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21764 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21765 }
21766 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21767 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21768 }
21769 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21770 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21771 }
21772 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21773 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21774 }
21775 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21776 return (void *)((wxObject *) ((wxImageHandler *) x));
21777 }
21778 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21779 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21780 }
21781 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21782 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21783 }
21784 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21785 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21786 }
21787 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21788 return (void *)((wxObject *) ((wxEvtHandler *) x));
21789 }
21790 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21791 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21792 }
21793 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21794 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21795 }
21796 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21797 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21798 }
21799 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21800 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21801 }
21802 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21803 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21804 }
21805 static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
21806 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21807 }
21808 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21809 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21810 }
21811 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21812 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21813 }
21814 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21815 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21816 }
21817 static void *_p_wxImageTo_p_wxObject(void *x) {
21818 return (void *)((wxObject *) ((wxImage *) x));
21819 }
21820 static void *_p_wxFrameTo_p_wxObject(void *x) {
21821 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21822 }
21823 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21824 return (void *)((wxObject *) ((wxPyPrintout *) x));
21825 }
21826 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21827 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21828 }
21829 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21830 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21831 }
21832 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21833 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21834 }
21835 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21836 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21837 }
21838 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21840 }
21841 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21842 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21843 }
21844 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21845 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21846 }
21847 static void *_p_wxWindowTo_p_wxObject(void *x) {
21848 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21849 }
21850 static void *_p_wxMenuTo_p_wxObject(void *x) {
21851 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21852 }
21853 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21854 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21855 }
21856 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21857 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21858 }
21859 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21860 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21861 }
21862 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21863 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21864 }
21865 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21866 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21867 }
21868 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21869 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21870 }
21871 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21872 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21873 }
21874 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21875 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21876 }
21877 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21878 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21879 }
21880 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21881 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21882 }
21883 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21884 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21885 }
21886 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21887 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21888 }
21889 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21890 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21891 }
21892 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21893 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21894 }
21895 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21896 return (void *)((wxObject *) ((wxPrintPreview *) x));
21897 }
21898 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21899 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21900 }
21901 static void *_p_wxPanelTo_p_wxObject(void *x) {
21902 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21903 }
21904 static void *_p_wxDialogTo_p_wxObject(void *x) {
21905 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21906 }
21907 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21908 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21909 }
21910 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21911 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21912 }
21913 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21914 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21915 }
21916 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21917 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21918 }
21919 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21920 return (void *)((wxObject *) ((wxPrintDialog *) x));
21921 }
21922 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21923 return (void *)((wxObject *) ((wxFileSystem *) x));
21924 }
21925 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21926 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21927 }
21928 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21929 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21930 }
21931 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21932 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21933 }
21934 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21935 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21936 }
21937 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21938 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21939 }
21940 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21941 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21942 }
21943 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21944 return (void *)((wxObject *) ((wxGridTableBase *) x));
21945 }
21946 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21947 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21948 }
21949 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21950 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21951 }
21952 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21953 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21954 }
21955 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21956 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21957 }
21958 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21959 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21960 }
21961 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21962 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21963 }
21964 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21965 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21966 }
21967 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21968 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21969 }
21970 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21971 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21972 }
21973 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21974 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21975 }
21976 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21977 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21978 }
21979 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21980 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21981 }
21982 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21983 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21984 }
21985 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21986 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21987 }
21988 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21989 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21990 }
21991 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
21992 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
21993 }
21994 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21995 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21996 }
21997 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21998 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21999 }
22000 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
22001 return (void *)((wxEvtHandler *) ((wxValidator *) x));
22002 }
22003 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
22004 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
22005 }
22006 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
22007 return (void *)((wxEvtHandler *) ((wxMenu *) x));
22008 }
22009 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
22010 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
22011 }
22012 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22013 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22014 }
22015 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22016 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22017 }
22018 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
22019 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
22020 }
22021 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
22022 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
22023 }
22024 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22025 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22026 }
22027 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22028 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22029 }
22030 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22031 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22032 }
22033 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22034 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22035 }
22036 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22037 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22038 }
22039 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22040 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22041 }
22042 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22043 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22044 }
22045 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22046 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
22047 }
22048 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22049 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22050 }
22051 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22052 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22053 }
22054 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22055 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22056 }
22057 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22058 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22059 }
22060 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22061 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22062 }
22063 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22064 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22065 }
22066 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22067 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22068 }
22069 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22070 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22071 }
22072 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22073 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22074 }
22075 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22076 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22077 }
22078 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22079 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22080 }
22081 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22082 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22083 }
22084 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22085 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22086 }
22087 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22088 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22089 }
22090 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22091 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22092 }
22093 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22094 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22095 }
22096 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22097 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22098 }
22099 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22100 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22101 }
22102 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22103 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22104 }
22105 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22106 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22107 }
22108 static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
22109 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
22110 }
22111 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22112 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22113 }
22114 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22115 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22116 }
22117 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22118 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22119 }
22120 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22121 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22122 }
22123 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22124 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22125 }
22126 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22127 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22128 }
22129 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22130 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22131 }
22132 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22133 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22134 }
22135 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22136 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22137 }
22138 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22139 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22140 }
22141 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22142 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22143 }
22144 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22145 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22146 }
22147 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22148 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22149 }
22150 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22151 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22152 }
22153 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22154 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22155 }
22156 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22157 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22158 }
22159 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22160 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22161 }
22162 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22163 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22164 }
22165 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22166 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22167 }
22168 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22169 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22170 }
22171 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22172 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22173 }
22174 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22175 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22176 }
22177 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22178 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22179 }
22180 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22181 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22182 }
22183 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22184 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22185 }
22186 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22187 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22188 }
22189 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22190 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22191 }
22192 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22193 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22194 }
22195 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22196 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22197 }
22198 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22199 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22200 }
22201 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22202 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22203 }
22204 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22205 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22206 }
22207 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22208 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22209 }
22210 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22211 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22212 }
22213 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22214 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22215 }
22216 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22217 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22218 }
22219 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22220 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22221 }
22222 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22223 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22224 }
22225 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22226 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22227 }
22228 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22229 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22230 }
22231 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22232 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22233 }
22234 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22235 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22236 }
22237 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22238 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22239 }
22240 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22241 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};
22242 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22243 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22244 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22245 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22246 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22247 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22248 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22249 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22250 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22255 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22256 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22257 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22258 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22259 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22260 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22263 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22265 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22266 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22267 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22272 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22273 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22274 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22275 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22276 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22277 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22278 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22279 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22280 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22281 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22282 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22283 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22284 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22285 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22286 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22287 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22288 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22289 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22290 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22291 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22292 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22293 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22294 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22295 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22296 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22297 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22298 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22299 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22300 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
22301 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22302 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22303 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22304 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22305 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22306 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22307 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22308 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22309 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22310 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22311 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22312 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22313 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22314 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22315 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22316 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22317 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22318 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22319 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22320 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22321 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22322 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22323 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22324 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22325 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22326 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22327 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22328 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22329 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22330 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22331 static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
22332 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22333 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22334 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22335 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22336 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22337 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22338 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22339 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22340 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22341 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22342 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22343 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22344 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22345 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22346 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22347 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22348 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22349 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22350 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22351 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22352 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22353 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22354 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22355 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22356 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22357 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22358 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22359 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22360 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22361 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22362 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22363 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22364 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22365 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22366 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22367 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22368 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22369 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22370 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22371 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22372 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22373 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22374 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22375 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22376 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22378 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22380 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22381 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22382 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22398 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22399 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22400 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22401 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22402 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22403 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22404 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22405 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22406 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22407 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22408 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22409 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22410 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22411 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22412 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22413 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22414 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22415 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22416 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22417 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22418 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22419 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22420 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22421 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22422 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22423 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22424 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22425 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22426 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22427 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22428 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22429 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22430 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22431 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22432 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22433 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22434
22435 static swig_type_info *swig_type_initial[] = {
22436 &_swigt__p_char,
22437 &_swigt__p_form_ops_t,
22438 &_swigt__p_int,
22439 &_swigt__p_long,
22440 &_swigt__p_unsigned_char,
22441 &_swigt__p_unsigned_int,
22442 &_swigt__p_unsigned_long,
22443 &_swigt__p_wxANIHandler,
22444 &_swigt__p_wxAcceleratorTable,
22445 &_swigt__p_wxActivateEvent,
22446 &_swigt__p_wxArrayString,
22447 &_swigt__p_wxBMPHandler,
22448 &_swigt__p_wxBoxSizer,
22449 &_swigt__p_wxCURHandler,
22450 &_swigt__p_wxCalculateLayoutEvent,
22451 &_swigt__p_wxChildFocusEvent,
22452 &_swigt__p_wxClipboardTextEvent,
22453 &_swigt__p_wxCloseEvent,
22454 &_swigt__p_wxColour,
22455 &_swigt__p_wxColourData,
22456 &_swigt__p_wxColourDialog,
22457 &_swigt__p_wxCommandEvent,
22458 &_swigt__p_wxContextMenuEvent,
22459 &_swigt__p_wxControl,
22460 &_swigt__p_wxControlWithItems,
22461 &_swigt__p_wxDC,
22462 &_swigt__p_wxDateEvent,
22463 &_swigt__p_wxDialog,
22464 &_swigt__p_wxDirDialog,
22465 &_swigt__p_wxDisplayChangedEvent,
22466 &_swigt__p_wxDropFilesEvent,
22467 &_swigt__p_wxDuplexMode,
22468 &_swigt__p_wxEraseEvent,
22469 &_swigt__p_wxEvent,
22470 &_swigt__p_wxEventBlocker,
22471 &_swigt__p_wxEvtHandler,
22472 &_swigt__p_wxFSFile,
22473 &_swigt__p_wxFileDialog,
22474 &_swigt__p_wxFileSystem,
22475 &_swigt__p_wxFindDialogEvent,
22476 &_swigt__p_wxFindReplaceData,
22477 &_swigt__p_wxFindReplaceDialog,
22478 &_swigt__p_wxFlexGridSizer,
22479 &_swigt__p_wxFocusEvent,
22480 &_swigt__p_wxFont,
22481 &_swigt__p_wxFontData,
22482 &_swigt__p_wxFontDialog,
22483 &_swigt__p_wxFrame,
22484 &_swigt__p_wxGBSizerItem,
22485 &_swigt__p_wxGIFHandler,
22486 &_swigt__p_wxGrid,
22487 &_swigt__p_wxGridBagSizer,
22488 &_swigt__p_wxGridCellAttr,
22489 &_swigt__p_wxGridCellAttrProvider,
22490 &_swigt__p_wxGridCellAutoWrapStringEditor,
22491 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22492 &_swigt__p_wxGridCellBoolEditor,
22493 &_swigt__p_wxGridCellBoolRenderer,
22494 &_swigt__p_wxGridCellChoiceEditor,
22495 &_swigt__p_wxGridCellCoords,
22496 &_swigt__p_wxGridCellDateTimeRenderer,
22497 &_swigt__p_wxGridCellEditor,
22498 &_swigt__p_wxGridCellEnumEditor,
22499 &_swigt__p_wxGridCellEnumRenderer,
22500 &_swigt__p_wxGridCellFloatEditor,
22501 &_swigt__p_wxGridCellFloatRenderer,
22502 &_swigt__p_wxGridCellNumberEditor,
22503 &_swigt__p_wxGridCellNumberRenderer,
22504 &_swigt__p_wxGridCellRenderer,
22505 &_swigt__p_wxGridCellStringRenderer,
22506 &_swigt__p_wxGridCellTextEditor,
22507 &_swigt__p_wxGridCellWorker,
22508 &_swigt__p_wxGridEditorCreatedEvent,
22509 &_swigt__p_wxGridEvent,
22510 &_swigt__p_wxGridRangeSelectEvent,
22511 &_swigt__p_wxGridSizeEvent,
22512 &_swigt__p_wxGridSizer,
22513 &_swigt__p_wxGridStringTable,
22514 &_swigt__p_wxGridTableBase,
22515 &_swigt__p_wxGridTableMessage,
22516 &_swigt__p_wxICOHandler,
22517 &_swigt__p_wxIconizeEvent,
22518 &_swigt__p_wxIdleEvent,
22519 &_swigt__p_wxImage,
22520 &_swigt__p_wxImageHandler,
22521 &_swigt__p_wxIndividualLayoutConstraint,
22522 &_swigt__p_wxInitDialogEvent,
22523 &_swigt__p_wxJPEGHandler,
22524 &_swigt__p_wxKeyEvent,
22525 &_swigt__p_wxLayoutAlgorithm,
22526 &_swigt__p_wxLayoutConstraints,
22527 &_swigt__p_wxMDIChildFrame,
22528 &_swigt__p_wxMDIClientWindow,
22529 &_swigt__p_wxMDIParentFrame,
22530 &_swigt__p_wxMaximizeEvent,
22531 &_swigt__p_wxMenu,
22532 &_swigt__p_wxMenuBar,
22533 &_swigt__p_wxMenuEvent,
22534 &_swigt__p_wxMenuItem,
22535 &_swigt__p_wxMessageDialog,
22536 &_swigt__p_wxMiniFrame,
22537 &_swigt__p_wxMouseCaptureChangedEvent,
22538 &_swigt__p_wxMouseCaptureLostEvent,
22539 &_swigt__p_wxMouseEvent,
22540 &_swigt__p_wxMoveEvent,
22541 &_swigt__p_wxMultiChoiceDialog,
22542 &_swigt__p_wxNavigationKeyEvent,
22543 &_swigt__p_wxNcPaintEvent,
22544 &_swigt__p_wxNotifyEvent,
22545 &_swigt__p_wxNumberEntryDialog,
22546 &_swigt__p_wxObject,
22547 &_swigt__p_wxPCXHandler,
22548 &_swigt__p_wxPNGHandler,
22549 &_swigt__p_wxPNMHandler,
22550 &_swigt__p_wxPageSetupDialog,
22551 &_swigt__p_wxPageSetupDialogData,
22552 &_swigt__p_wxPaintEvent,
22553 &_swigt__p_wxPaletteChangedEvent,
22554 &_swigt__p_wxPanel,
22555 &_swigt__p_wxPaperSize,
22556 &_swigt__p_wxPasswordEntryDialog,
22557 &_swigt__p_wxPen,
22558 &_swigt__p_wxPoint,
22559 &_swigt__p_wxPopupWindow,
22560 &_swigt__p_wxPreviewCanvas,
22561 &_swigt__p_wxPreviewControlBar,
22562 &_swigt__p_wxPreviewFrame,
22563 &_swigt__p_wxPrintData,
22564 &_swigt__p_wxPrintDialog,
22565 &_swigt__p_wxPrintDialogData,
22566 &_swigt__p_wxPrintPreview,
22567 &_swigt__p_wxPrinter,
22568 &_swigt__p_wxProgressDialog,
22569 &_swigt__p_wxPyApp,
22570 &_swigt__p_wxPyCommandEvent,
22571 &_swigt__p_wxPyEvent,
22572 &_swigt__p_wxPyGridCellAttrProvider,
22573 &_swigt__p_wxPyGridCellEditor,
22574 &_swigt__p_wxPyGridCellRenderer,
22575 &_swigt__p_wxPyGridTableBase,
22576 &_swigt__p_wxPyHtmlListBox,
22577 &_swigt__p_wxPyImageHandler,
22578 &_swigt__p_wxPyPanel,
22579 &_swigt__p_wxPyPopupTransientWindow,
22580 &_swigt__p_wxPyPreviewControlBar,
22581 &_swigt__p_wxPyPreviewFrame,
22582 &_swigt__p_wxPyPrintPreview,
22583 &_swigt__p_wxPyPrintout,
22584 &_swigt__p_wxPyScrolledWindow,
22585 &_swigt__p_wxPySizer,
22586 &_swigt__p_wxPyTaskBarIcon,
22587 &_swigt__p_wxPyVListBox,
22588 &_swigt__p_wxPyVScrolledWindow,
22589 &_swigt__p_wxPyValidator,
22590 &_swigt__p_wxPyWindow,
22591 &_swigt__p_wxQueryLayoutInfoEvent,
22592 &_swigt__p_wxQueryNewPaletteEvent,
22593 &_swigt__p_wxRect,
22594 &_swigt__p_wxSashEvent,
22595 &_swigt__p_wxSashLayoutWindow,
22596 &_swigt__p_wxSashWindow,
22597 &_swigt__p_wxScrollEvent,
22598 &_swigt__p_wxScrollWinEvent,
22599 &_swigt__p_wxScrolledWindow,
22600 &_swigt__p_wxSetCursorEvent,
22601 &_swigt__p_wxShowEvent,
22602 &_swigt__p_wxSimpleHtmlListBox,
22603 &_swigt__p_wxSingleChoiceDialog,
22604 &_swigt__p_wxSize,
22605 &_swigt__p_wxSizeEvent,
22606 &_swigt__p_wxSizer,
22607 &_swigt__p_wxSizerItem,
22608 &_swigt__p_wxSplashScreen,
22609 &_swigt__p_wxSplashScreenWindow,
22610 &_swigt__p_wxSplitterEvent,
22611 &_swigt__p_wxSplitterWindow,
22612 &_swigt__p_wxStaticBoxSizer,
22613 &_swigt__p_wxStatusBar,
22614 &_swigt__p_wxStdDialogButtonSizer,
22615 &_swigt__p_wxString,
22616 &_swigt__p_wxSysColourChangedEvent,
22617 &_swigt__p_wxTGAHandler,
22618 &_swigt__p_wxTIFFHandler,
22619 &_swigt__p_wxTaskBarIconEvent,
22620 &_swigt__p_wxTextEntryDialog,
22621 &_swigt__p_wxTipWindow,
22622 &_swigt__p_wxTopLevelWindow,
22623 &_swigt__p_wxUpdateUIEvent,
22624 &_swigt__p_wxValidator,
22625 &_swigt__p_wxVisualAttributes,
22626 &_swigt__p_wxWindow,
22627 &_swigt__p_wxWindowCreateEvent,
22628 &_swigt__p_wxWindowDestroyEvent,
22629 &_swigt__p_wxXPMHandler,
22630 };
22631
22632 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22643 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22644 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22645 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22646 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22647 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22653 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}};
22654 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22655 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}};
22656 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22658 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22659 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22662 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22663 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22667 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22668 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22672 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22673 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22674 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22675 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22676 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22677 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22678 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22679 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22680 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22681 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22682 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22683 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22684 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22685 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22686 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22687 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
22688 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22689 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22690 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22691 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
22692 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22693 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22694 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22695 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22696 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22697 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22698 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22699 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22700 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22701 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22702 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22703 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22704 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22705 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22706 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22707 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22708 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22709 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22710 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22711 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22712 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22713 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22714 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22715 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22716 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22717 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22718 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22719 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22720 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22721 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22722 static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22723 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22724 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22725 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22726 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22727 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22728 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22729 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22730 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22731 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22732 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22733 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22734 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22735 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_wxEventBlocker, _p_wxEventBlockerTo_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_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_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_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_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_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_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22736 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22737 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22738 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22739 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}};
22740 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22741 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22742 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22743 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22744 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}};
22745 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22746 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22747 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}};
22748 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22749 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22752 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22753 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22754 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}};
22755 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}};
22756 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}};
22757 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}};
22758 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22763 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}};
22764 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22766 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}};
22767 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22770 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22771 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22772 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22773 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22778 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22779 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22794 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22795 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22798 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22799 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22800 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22801 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22802 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22803 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22804 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22805 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22806 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22807 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22808 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22809 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22810 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22811 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_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_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22812 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22813 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22814 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22815 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22816 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22817 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22818 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22819 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22820 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22821 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}};
22822 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22823 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22824 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22825 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22826
22827 static swig_cast_info *swig_cast_initial[] = {
22828 _swigc__p_char,
22829 _swigc__p_form_ops_t,
22830 _swigc__p_int,
22831 _swigc__p_long,
22832 _swigc__p_unsigned_char,
22833 _swigc__p_unsigned_int,
22834 _swigc__p_unsigned_long,
22835 _swigc__p_wxANIHandler,
22836 _swigc__p_wxAcceleratorTable,
22837 _swigc__p_wxActivateEvent,
22838 _swigc__p_wxArrayString,
22839 _swigc__p_wxBMPHandler,
22840 _swigc__p_wxBoxSizer,
22841 _swigc__p_wxCURHandler,
22842 _swigc__p_wxCalculateLayoutEvent,
22843 _swigc__p_wxChildFocusEvent,
22844 _swigc__p_wxClipboardTextEvent,
22845 _swigc__p_wxCloseEvent,
22846 _swigc__p_wxColour,
22847 _swigc__p_wxColourData,
22848 _swigc__p_wxColourDialog,
22849 _swigc__p_wxCommandEvent,
22850 _swigc__p_wxContextMenuEvent,
22851 _swigc__p_wxControl,
22852 _swigc__p_wxControlWithItems,
22853 _swigc__p_wxDC,
22854 _swigc__p_wxDateEvent,
22855 _swigc__p_wxDialog,
22856 _swigc__p_wxDirDialog,
22857 _swigc__p_wxDisplayChangedEvent,
22858 _swigc__p_wxDropFilesEvent,
22859 _swigc__p_wxDuplexMode,
22860 _swigc__p_wxEraseEvent,
22861 _swigc__p_wxEvent,
22862 _swigc__p_wxEventBlocker,
22863 _swigc__p_wxEvtHandler,
22864 _swigc__p_wxFSFile,
22865 _swigc__p_wxFileDialog,
22866 _swigc__p_wxFileSystem,
22867 _swigc__p_wxFindDialogEvent,
22868 _swigc__p_wxFindReplaceData,
22869 _swigc__p_wxFindReplaceDialog,
22870 _swigc__p_wxFlexGridSizer,
22871 _swigc__p_wxFocusEvent,
22872 _swigc__p_wxFont,
22873 _swigc__p_wxFontData,
22874 _swigc__p_wxFontDialog,
22875 _swigc__p_wxFrame,
22876 _swigc__p_wxGBSizerItem,
22877 _swigc__p_wxGIFHandler,
22878 _swigc__p_wxGrid,
22879 _swigc__p_wxGridBagSizer,
22880 _swigc__p_wxGridCellAttr,
22881 _swigc__p_wxGridCellAttrProvider,
22882 _swigc__p_wxGridCellAutoWrapStringEditor,
22883 _swigc__p_wxGridCellAutoWrapStringRenderer,
22884 _swigc__p_wxGridCellBoolEditor,
22885 _swigc__p_wxGridCellBoolRenderer,
22886 _swigc__p_wxGridCellChoiceEditor,
22887 _swigc__p_wxGridCellCoords,
22888 _swigc__p_wxGridCellDateTimeRenderer,
22889 _swigc__p_wxGridCellEditor,
22890 _swigc__p_wxGridCellEnumEditor,
22891 _swigc__p_wxGridCellEnumRenderer,
22892 _swigc__p_wxGridCellFloatEditor,
22893 _swigc__p_wxGridCellFloatRenderer,
22894 _swigc__p_wxGridCellNumberEditor,
22895 _swigc__p_wxGridCellNumberRenderer,
22896 _swigc__p_wxGridCellRenderer,
22897 _swigc__p_wxGridCellStringRenderer,
22898 _swigc__p_wxGridCellTextEditor,
22899 _swigc__p_wxGridCellWorker,
22900 _swigc__p_wxGridEditorCreatedEvent,
22901 _swigc__p_wxGridEvent,
22902 _swigc__p_wxGridRangeSelectEvent,
22903 _swigc__p_wxGridSizeEvent,
22904 _swigc__p_wxGridSizer,
22905 _swigc__p_wxGridStringTable,
22906 _swigc__p_wxGridTableBase,
22907 _swigc__p_wxGridTableMessage,
22908 _swigc__p_wxICOHandler,
22909 _swigc__p_wxIconizeEvent,
22910 _swigc__p_wxIdleEvent,
22911 _swigc__p_wxImage,
22912 _swigc__p_wxImageHandler,
22913 _swigc__p_wxIndividualLayoutConstraint,
22914 _swigc__p_wxInitDialogEvent,
22915 _swigc__p_wxJPEGHandler,
22916 _swigc__p_wxKeyEvent,
22917 _swigc__p_wxLayoutAlgorithm,
22918 _swigc__p_wxLayoutConstraints,
22919 _swigc__p_wxMDIChildFrame,
22920 _swigc__p_wxMDIClientWindow,
22921 _swigc__p_wxMDIParentFrame,
22922 _swigc__p_wxMaximizeEvent,
22923 _swigc__p_wxMenu,
22924 _swigc__p_wxMenuBar,
22925 _swigc__p_wxMenuEvent,
22926 _swigc__p_wxMenuItem,
22927 _swigc__p_wxMessageDialog,
22928 _swigc__p_wxMiniFrame,
22929 _swigc__p_wxMouseCaptureChangedEvent,
22930 _swigc__p_wxMouseCaptureLostEvent,
22931 _swigc__p_wxMouseEvent,
22932 _swigc__p_wxMoveEvent,
22933 _swigc__p_wxMultiChoiceDialog,
22934 _swigc__p_wxNavigationKeyEvent,
22935 _swigc__p_wxNcPaintEvent,
22936 _swigc__p_wxNotifyEvent,
22937 _swigc__p_wxNumberEntryDialog,
22938 _swigc__p_wxObject,
22939 _swigc__p_wxPCXHandler,
22940 _swigc__p_wxPNGHandler,
22941 _swigc__p_wxPNMHandler,
22942 _swigc__p_wxPageSetupDialog,
22943 _swigc__p_wxPageSetupDialogData,
22944 _swigc__p_wxPaintEvent,
22945 _swigc__p_wxPaletteChangedEvent,
22946 _swigc__p_wxPanel,
22947 _swigc__p_wxPaperSize,
22948 _swigc__p_wxPasswordEntryDialog,
22949 _swigc__p_wxPen,
22950 _swigc__p_wxPoint,
22951 _swigc__p_wxPopupWindow,
22952 _swigc__p_wxPreviewCanvas,
22953 _swigc__p_wxPreviewControlBar,
22954 _swigc__p_wxPreviewFrame,
22955 _swigc__p_wxPrintData,
22956 _swigc__p_wxPrintDialog,
22957 _swigc__p_wxPrintDialogData,
22958 _swigc__p_wxPrintPreview,
22959 _swigc__p_wxPrinter,
22960 _swigc__p_wxProgressDialog,
22961 _swigc__p_wxPyApp,
22962 _swigc__p_wxPyCommandEvent,
22963 _swigc__p_wxPyEvent,
22964 _swigc__p_wxPyGridCellAttrProvider,
22965 _swigc__p_wxPyGridCellEditor,
22966 _swigc__p_wxPyGridCellRenderer,
22967 _swigc__p_wxPyGridTableBase,
22968 _swigc__p_wxPyHtmlListBox,
22969 _swigc__p_wxPyImageHandler,
22970 _swigc__p_wxPyPanel,
22971 _swigc__p_wxPyPopupTransientWindow,
22972 _swigc__p_wxPyPreviewControlBar,
22973 _swigc__p_wxPyPreviewFrame,
22974 _swigc__p_wxPyPrintPreview,
22975 _swigc__p_wxPyPrintout,
22976 _swigc__p_wxPyScrolledWindow,
22977 _swigc__p_wxPySizer,
22978 _swigc__p_wxPyTaskBarIcon,
22979 _swigc__p_wxPyVListBox,
22980 _swigc__p_wxPyVScrolledWindow,
22981 _swigc__p_wxPyValidator,
22982 _swigc__p_wxPyWindow,
22983 _swigc__p_wxQueryLayoutInfoEvent,
22984 _swigc__p_wxQueryNewPaletteEvent,
22985 _swigc__p_wxRect,
22986 _swigc__p_wxSashEvent,
22987 _swigc__p_wxSashLayoutWindow,
22988 _swigc__p_wxSashWindow,
22989 _swigc__p_wxScrollEvent,
22990 _swigc__p_wxScrollWinEvent,
22991 _swigc__p_wxScrolledWindow,
22992 _swigc__p_wxSetCursorEvent,
22993 _swigc__p_wxShowEvent,
22994 _swigc__p_wxSimpleHtmlListBox,
22995 _swigc__p_wxSingleChoiceDialog,
22996 _swigc__p_wxSize,
22997 _swigc__p_wxSizeEvent,
22998 _swigc__p_wxSizer,
22999 _swigc__p_wxSizerItem,
23000 _swigc__p_wxSplashScreen,
23001 _swigc__p_wxSplashScreenWindow,
23002 _swigc__p_wxSplitterEvent,
23003 _swigc__p_wxSplitterWindow,
23004 _swigc__p_wxStaticBoxSizer,
23005 _swigc__p_wxStatusBar,
23006 _swigc__p_wxStdDialogButtonSizer,
23007 _swigc__p_wxString,
23008 _swigc__p_wxSysColourChangedEvent,
23009 _swigc__p_wxTGAHandler,
23010 _swigc__p_wxTIFFHandler,
23011 _swigc__p_wxTaskBarIconEvent,
23012 _swigc__p_wxTextEntryDialog,
23013 _swigc__p_wxTipWindow,
23014 _swigc__p_wxTopLevelWindow,
23015 _swigc__p_wxUpdateUIEvent,
23016 _swigc__p_wxValidator,
23017 _swigc__p_wxVisualAttributes,
23018 _swigc__p_wxWindow,
23019 _swigc__p_wxWindowCreateEvent,
23020 _swigc__p_wxWindowDestroyEvent,
23021 _swigc__p_wxXPMHandler,
23022 };
23023
23024
23025 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23026
23027 static swig_const_info swig_const_table[] = {
23028 {0, 0, 0, 0.0, 0, 0}};
23029
23030 #ifdef __cplusplus
23031 }
23032 #endif
23033 /* -----------------------------------------------------------------------------
23034 * Type initialization:
23035 * This problem is tough by the requirement that no dynamic
23036 * memory is used. Also, since swig_type_info structures store pointers to
23037 * swig_cast_info structures and swig_cast_info structures store pointers back
23038 * to swig_type_info structures, we need some lookup code at initialization.
23039 * The idea is that swig generates all the structures that are needed.
23040 * The runtime then collects these partially filled structures.
23041 * The SWIG_InitializeModule function takes these initial arrays out of
23042 * swig_module, and does all the lookup, filling in the swig_module.types
23043 * array with the correct data and linking the correct swig_cast_info
23044 * structures together.
23045 *
23046 * The generated swig_type_info structures are assigned staticly to an initial
23047 * array. We just loop though that array, and handle each type individually.
23048 * First we lookup if this type has been already loaded, and if so, use the
23049 * loaded structure instead of the generated one. Then we have to fill in the
23050 * cast linked list. The cast data is initially stored in something like a
23051 * two-dimensional array. Each row corresponds to a type (there are the same
23052 * number of rows as there are in the swig_type_initial array). Each entry in
23053 * a column is one of the swig_cast_info structures for that type.
23054 * The cast_initial array is actually an array of arrays, because each row has
23055 * a variable number of columns. So to actually build the cast linked list,
23056 * we find the array of casts associated with the type, and loop through it
23057 * adding the casts to the list. The one last trick we need to do is making
23058 * sure the type pointer in the swig_cast_info struct is correct.
23059 *
23060 * First off, we lookup the cast->type name to see if it is already loaded.
23061 * There are three cases to handle:
23062 * 1) If the cast->type has already been loaded AND the type we are adding
23063 * casting info to has not been loaded (it is in this module), THEN we
23064 * replace the cast->type pointer with the type pointer that has already
23065 * been loaded.
23066 * 2) If BOTH types (the one we are adding casting info to, and the
23067 * cast->type) are loaded, THEN the cast info has already been loaded by
23068 * the previous module so we just ignore it.
23069 * 3) Finally, if cast->type has not already been loaded, then we add that
23070 * swig_cast_info to the linked list (because the cast->type) pointer will
23071 * be correct.
23072 * ----------------------------------------------------------------------------- */
23073
23074 #ifdef __cplusplus
23075 extern "C" {
23076 #if 0
23077 } /* c-mode */
23078 #endif
23079 #endif
23080
23081 #if 0
23082 #define SWIGRUNTIME_DEBUG
23083 #endif
23084
23085 SWIGRUNTIME void
23086 SWIG_InitializeModule(void *clientdata) {
23087 size_t i;
23088 swig_module_info *module_head;
23089 static int init_run = 0;
23090
23091 clientdata = clientdata;
23092
23093 if (init_run) return;
23094 init_run = 1;
23095
23096 /* Initialize the swig_module */
23097 swig_module.type_initial = swig_type_initial;
23098 swig_module.cast_initial = swig_cast_initial;
23099
23100 /* Try and load any already created modules */
23101 module_head = SWIG_GetModule(clientdata);
23102 if (module_head) {
23103 swig_module.next = module_head->next;
23104 module_head->next = &swig_module;
23105 } else {
23106 /* This is the first module loaded */
23107 swig_module.next = &swig_module;
23108 SWIG_SetModule(clientdata, &swig_module);
23109 }
23110
23111 /* Now work on filling in swig_module.types */
23112 #ifdef SWIGRUNTIME_DEBUG
23113 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23114 #endif
23115 for (i = 0; i < swig_module.size; ++i) {
23116 swig_type_info *type = 0;
23117 swig_type_info *ret;
23118 swig_cast_info *cast;
23119
23120 #ifdef SWIGRUNTIME_DEBUG
23121 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23122 #endif
23123
23124 /* if there is another module already loaded */
23125 if (swig_module.next != &swig_module) {
23126 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23127 }
23128 if (type) {
23129 /* Overwrite clientdata field */
23130 #ifdef SWIGRUNTIME_DEBUG
23131 printf("SWIG_InitializeModule: found type %s\n", type->name);
23132 #endif
23133 if (swig_module.type_initial[i]->clientdata) {
23134 type->clientdata = swig_module.type_initial[i]->clientdata;
23135 #ifdef SWIGRUNTIME_DEBUG
23136 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23137 #endif
23138 }
23139 } else {
23140 type = swig_module.type_initial[i];
23141 }
23142
23143 /* Insert casting types */
23144 cast = swig_module.cast_initial[i];
23145 while (cast->type) {
23146 /* Don't need to add information already in the list */
23147 ret = 0;
23148 #ifdef SWIGRUNTIME_DEBUG
23149 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23150 #endif
23151 if (swig_module.next != &swig_module) {
23152 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23153 #ifdef SWIGRUNTIME_DEBUG
23154 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23155 #endif
23156 }
23157 if (ret) {
23158 if (type == swig_module.type_initial[i]) {
23159 #ifdef SWIGRUNTIME_DEBUG
23160 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23161 #endif
23162 cast->type = ret;
23163 ret = 0;
23164 } else {
23165 /* Check for casting already in the list */
23166 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23167 #ifdef SWIGRUNTIME_DEBUG
23168 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23169 #endif
23170 if (!ocast) ret = 0;
23171 }
23172 }
23173
23174 if (!ret) {
23175 #ifdef SWIGRUNTIME_DEBUG
23176 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23177 #endif
23178 if (type->cast) {
23179 type->cast->prev = cast;
23180 cast->next = type->cast;
23181 }
23182 type->cast = cast;
23183 }
23184 cast++;
23185 }
23186 /* Set entry in modules->types array equal to the type */
23187 swig_module.types[i] = type;
23188 }
23189 swig_module.types[i] = 0;
23190
23191 #ifdef SWIGRUNTIME_DEBUG
23192 printf("**** SWIG_InitializeModule: Cast List ******\n");
23193 for (i = 0; i < swig_module.size; ++i) {
23194 int j = 0;
23195 swig_cast_info *cast = swig_module.cast_initial[i];
23196 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23197 while (cast->type) {
23198 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23199 cast++;
23200 ++j;
23201 }
23202 printf("---- Total casts: %d\n",j);
23203 }
23204 printf("**** SWIG_InitializeModule: Cast List ******\n");
23205 #endif
23206 }
23207
23208 /* This function will propagate the clientdata field of type to
23209 * any new swig_type_info structures that have been added into the list
23210 * of equivalent types. It is like calling
23211 * SWIG_TypeClientData(type, clientdata) a second time.
23212 */
23213 SWIGRUNTIME void
23214 SWIG_PropagateClientData(void) {
23215 size_t i;
23216 swig_cast_info *equiv;
23217 static int init_run = 0;
23218
23219 if (init_run) return;
23220 init_run = 1;
23221
23222 for (i = 0; i < swig_module.size; i++) {
23223 if (swig_module.types[i]->clientdata) {
23224 equiv = swig_module.types[i]->cast;
23225 while (equiv) {
23226 if (!equiv->converter) {
23227 if (equiv->type && !equiv->type->clientdata)
23228 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23229 }
23230 equiv = equiv->next;
23231 }
23232 }
23233 }
23234 }
23235
23236 #ifdef __cplusplus
23237 #if 0
23238 {
23239 /* c-mode */
23240 #endif
23241 }
23242 #endif
23243
23244
23245
23246 #ifdef __cplusplus
23247 extern "C" {
23248 #endif
23249
23250 /* Python-specific SWIG API */
23251 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23252 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23253 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23254
23255 /* -----------------------------------------------------------------------------
23256 * global variable support code.
23257 * ----------------------------------------------------------------------------- */
23258
23259 typedef struct swig_globalvar {
23260 char *name; /* Name of global variable */
23261 PyObject *(*get_attr)(void); /* Return the current value */
23262 int (*set_attr)(PyObject *); /* Set the value */
23263 struct swig_globalvar *next;
23264 } swig_globalvar;
23265
23266 typedef struct swig_varlinkobject {
23267 PyObject_HEAD
23268 swig_globalvar *vars;
23269 } swig_varlinkobject;
23270
23271 SWIGINTERN PyObject *
23272 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23273 return PyString_FromString("<Swig global variables>");
23274 }
23275
23276 SWIGINTERN PyObject *
23277 swig_varlink_str(swig_varlinkobject *v) {
23278 PyObject *str = PyString_FromString("(");
23279 swig_globalvar *var;
23280 for (var = v->vars; var; var=var->next) {
23281 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23282 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23283 }
23284 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23285 return str;
23286 }
23287
23288 SWIGINTERN int
23289 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23290 PyObject *str = swig_varlink_str(v);
23291 fprintf(fp,"Swig global variables ");
23292 fprintf(fp,"%s\n", PyString_AsString(str));
23293 Py_DECREF(str);
23294 return 0;
23295 }
23296
23297 SWIGINTERN void
23298 swig_varlink_dealloc(swig_varlinkobject *v) {
23299 swig_globalvar *var = v->vars;
23300 while (var) {
23301 swig_globalvar *n = var->next;
23302 free(var->name);
23303 free(var);
23304 var = n;
23305 }
23306 }
23307
23308 SWIGINTERN PyObject *
23309 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23310 PyObject *res = NULL;
23311 swig_globalvar *var = v->vars;
23312 while (var) {
23313 if (strcmp(var->name,n) == 0) {
23314 res = (*var->get_attr)();
23315 break;
23316 }
23317 var = var->next;
23318 }
23319 if (res == NULL && !PyErr_Occurred()) {
23320 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23321 }
23322 return res;
23323 }
23324
23325 SWIGINTERN int
23326 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23327 int res = 1;
23328 swig_globalvar *var = v->vars;
23329 while (var) {
23330 if (strcmp(var->name,n) == 0) {
23331 res = (*var->set_attr)(p);
23332 break;
23333 }
23334 var = var->next;
23335 }
23336 if (res == 1 && !PyErr_Occurred()) {
23337 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23338 }
23339 return res;
23340 }
23341
23342 SWIGINTERN PyTypeObject*
23343 swig_varlink_type(void) {
23344 static char varlink__doc__[] = "Swig var link object";
23345 static PyTypeObject varlink_type;
23346 static int type_init = 0;
23347 if (!type_init) {
23348 const PyTypeObject tmp
23349 = {
23350 PyObject_HEAD_INIT(NULL)
23351 0, /* Number of items in variable part (ob_size) */
23352 (char *)"swigvarlink", /* Type name (tp_name) */
23353 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23354 0, /* Itemsize (tp_itemsize) */
23355 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23356 (printfunc) swig_varlink_print, /* Print (tp_print) */
23357 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23358 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23359 0, /* tp_compare */
23360 (reprfunc) swig_varlink_repr, /* tp_repr */
23361 0, /* tp_as_number */
23362 0, /* tp_as_sequence */
23363 0, /* tp_as_mapping */
23364 0, /* tp_hash */
23365 0, /* tp_call */
23366 (reprfunc)swig_varlink_str, /* tp_str */
23367 0, /* tp_getattro */
23368 0, /* tp_setattro */
23369 0, /* tp_as_buffer */
23370 0, /* tp_flags */
23371 varlink__doc__, /* tp_doc */
23372 0, /* tp_traverse */
23373 0, /* tp_clear */
23374 0, /* tp_richcompare */
23375 0, /* tp_weaklistoffset */
23376 #if PY_VERSION_HEX >= 0x02020000
23377 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23378 #endif
23379 #if PY_VERSION_HEX >= 0x02030000
23380 0, /* tp_del */
23381 #endif
23382 #ifdef COUNT_ALLOCS
23383 0,0,0,0 /* tp_alloc -> tp_next */
23384 #endif
23385 };
23386 varlink_type = tmp;
23387 varlink_type.ob_type = &PyType_Type;
23388 type_init = 1;
23389 }
23390 return &varlink_type;
23391 }
23392
23393 /* Create a variable linking object for use later */
23394 SWIGINTERN PyObject *
23395 SWIG_Python_newvarlink(void) {
23396 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23397 if (result) {
23398 result->vars = 0;
23399 }
23400 return ((PyObject*) result);
23401 }
23402
23403 SWIGINTERN void
23404 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23405 swig_varlinkobject *v = (swig_varlinkobject *) p;
23406 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23407 if (gv) {
23408 size_t size = strlen(name)+1;
23409 gv->name = (char *)malloc(size);
23410 if (gv->name) {
23411 strncpy(gv->name,name,size);
23412 gv->get_attr = get_attr;
23413 gv->set_attr = set_attr;
23414 gv->next = v->vars;
23415 }
23416 }
23417 v->vars = gv;
23418 }
23419
23420 SWIGINTERN PyObject *
23421 SWIG_globals() {
23422 static PyObject *_SWIG_globals = 0;
23423 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23424 return _SWIG_globals;
23425 }
23426
23427 /* -----------------------------------------------------------------------------
23428 * constants/methods manipulation
23429 * ----------------------------------------------------------------------------- */
23430
23431 /* Install Constants */
23432 SWIGINTERN void
23433 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23434 PyObject *obj = 0;
23435 size_t i;
23436 for (i = 0; constants[i].type; ++i) {
23437 switch(constants[i].type) {
23438 case SWIG_PY_POINTER:
23439 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23440 break;
23441 case SWIG_PY_BINARY:
23442 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23443 break;
23444 default:
23445 obj = 0;
23446 break;
23447 }
23448 if (obj) {
23449 PyDict_SetItemString(d, constants[i].name, obj);
23450 Py_DECREF(obj);
23451 }
23452 }
23453 }
23454
23455 /* -----------------------------------------------------------------------------*/
23456 /* Fix SwigMethods to carry the callback ptrs when needed */
23457 /* -----------------------------------------------------------------------------*/
23458
23459 SWIGINTERN void
23460 SWIG_Python_FixMethods(PyMethodDef *methods,
23461 swig_const_info *const_table,
23462 swig_type_info **types,
23463 swig_type_info **types_initial) {
23464 size_t i;
23465 for (i = 0; methods[i].ml_name; ++i) {
23466 const char *c = methods[i].ml_doc;
23467 if (c && (c = strstr(c, "swig_ptr: "))) {
23468 int j;
23469 swig_const_info *ci = 0;
23470 const char *name = c + 10;
23471 for (j = 0; const_table[j].type; ++j) {
23472 if (strncmp(const_table[j].name, name,
23473 strlen(const_table[j].name)) == 0) {
23474 ci = &(const_table[j]);
23475 break;
23476 }
23477 }
23478 if (ci) {
23479 size_t shift = (ci->ptype) - types;
23480 swig_type_info *ty = types_initial[shift];
23481 size_t ldoc = (c - methods[i].ml_doc);
23482 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23483 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23484 if (ndoc) {
23485 char *buff = ndoc;
23486 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23487 if (ptr) {
23488 strncpy(buff, methods[i].ml_doc, ldoc);
23489 buff += ldoc;
23490 strncpy(buff, "swig_ptr: ", 10);
23491 buff += 10;
23492 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23493 methods[i].ml_doc = ndoc;
23494 }
23495 }
23496 }
23497 }
23498 }
23499 }
23500
23501 #ifdef __cplusplus
23502 }
23503 #endif
23504
23505 /* -----------------------------------------------------------------------------*
23506 * Partial Init method
23507 * -----------------------------------------------------------------------------*/
23508
23509 #ifdef __cplusplus
23510 extern "C"
23511 #endif
23512 SWIGEXPORT void SWIG_init(void) {
23513 PyObject *m, *d;
23514
23515 /* Fix SwigMethods to carry the callback ptrs when needed */
23516 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23517
23518 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23519 d = PyModule_GetDict(m);
23520
23521 SWIG_InitializeModule(0);
23522 SWIG_InstallConstants(d,swig_const_table);
23523
23524
23525 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23526 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23527 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23528 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23529 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23530 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23531 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23532 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23533 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23534 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23535 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23536 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23537 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23538 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23539 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23540 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23541 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23542 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23543 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23544 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23545 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23546 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23547 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23548 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23549 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23550 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23551 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23552 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23553 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23554 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23555 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23556 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23557 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23558 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23559 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23560 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23561 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23562 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23563 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23564 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23565 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23566 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23567 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23568 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23569 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23570 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23571 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23572 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23573 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23574 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23575 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23576 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23577 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23578 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23579 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23580 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23581 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23582
23583
23584 }
23585
wxWidgets (Impactor)