]> 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
Build fix after PRIOR/NEXT removal.
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_long swig_types[3]
2466 #define SWIGTYPE_p_unsigned_char swig_types[4]
2467 #define SWIGTYPE_p_unsigned_int swig_types[5]
2468 #define SWIGTYPE_p_unsigned_long swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2475 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2476 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2477 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2478 #define SWIGTYPE_p_wxCloseEvent swig_types[16]
2479 #define SWIGTYPE_p_wxColour swig_types[17]
2480 #define SWIGTYPE_p_wxColourData swig_types[18]
2481 #define SWIGTYPE_p_wxColourDialog swig_types[19]
2482 #define SWIGTYPE_p_wxCommandEvent swig_types[20]
2483 #define SWIGTYPE_p_wxContextMenuEvent swig_types[21]
2484 #define SWIGTYPE_p_wxControl swig_types[22]
2485 #define SWIGTYPE_p_wxControlWithItems swig_types[23]
2486 #define SWIGTYPE_p_wxDC swig_types[24]
2487 #define SWIGTYPE_p_wxDateEvent swig_types[25]
2488 #define SWIGTYPE_p_wxDialog swig_types[26]
2489 #define SWIGTYPE_p_wxDirDialog swig_types[27]
2490 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[28]
2491 #define SWIGTYPE_p_wxDropFilesEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDuplexMode swig_types[30]
2493 #define SWIGTYPE_p_wxEraseEvent swig_types[31]
2494 #define SWIGTYPE_p_wxEvent swig_types[32]
2495 #define SWIGTYPE_p_wxEvtHandler swig_types[33]
2496 #define SWIGTYPE_p_wxFSFile swig_types[34]
2497 #define SWIGTYPE_p_wxFileDialog swig_types[35]
2498 #define SWIGTYPE_p_wxFileSystem swig_types[36]
2499 #define SWIGTYPE_p_wxFindDialogEvent swig_types[37]
2500 #define SWIGTYPE_p_wxFindReplaceData swig_types[38]
2501 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[39]
2502 #define SWIGTYPE_p_wxFlexGridSizer swig_types[40]
2503 #define SWIGTYPE_p_wxFocusEvent swig_types[41]
2504 #define SWIGTYPE_p_wxFont swig_types[42]
2505 #define SWIGTYPE_p_wxFontData swig_types[43]
2506 #define SWIGTYPE_p_wxFontDialog swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBSizerItem swig_types[46]
2509 #define SWIGTYPE_p_wxGIFHandler swig_types[47]
2510 #define SWIGTYPE_p_wxGrid swig_types[48]
2511 #define SWIGTYPE_p_wxGridBagSizer swig_types[49]
2512 #define SWIGTYPE_p_wxGridCellAttr swig_types[50]
2513 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[51]
2514 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[52]
2515 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[53]
2516 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[54]
2517 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[55]
2518 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[56]
2519 #define SWIGTYPE_p_wxGridCellCoords swig_types[57]
2520 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[58]
2521 #define SWIGTYPE_p_wxGridCellEditor swig_types[59]
2522 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[60]
2523 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[61]
2524 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[62]
2525 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[63]
2526 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[64]
2527 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[65]
2528 #define SWIGTYPE_p_wxGridCellRenderer swig_types[66]
2529 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[67]
2530 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[68]
2531 #define SWIGTYPE_p_wxGridCellWorker swig_types[69]
2532 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[70]
2533 #define SWIGTYPE_p_wxGridEvent swig_types[71]
2534 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[72]
2535 #define SWIGTYPE_p_wxGridSizeEvent swig_types[73]
2536 #define SWIGTYPE_p_wxGridSizer swig_types[74]
2537 #define SWIGTYPE_p_wxGridStringTable swig_types[75]
2538 #define SWIGTYPE_p_wxGridTableBase swig_types[76]
2539 #define SWIGTYPE_p_wxGridTableMessage swig_types[77]
2540 #define SWIGTYPE_p_wxICOHandler swig_types[78]
2541 #define SWIGTYPE_p_wxIconizeEvent swig_types[79]
2542 #define SWIGTYPE_p_wxIdleEvent swig_types[80]
2543 #define SWIGTYPE_p_wxImage swig_types[81]
2544 #define SWIGTYPE_p_wxImageHandler swig_types[82]
2545 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[83]
2546 #define SWIGTYPE_p_wxInitDialogEvent swig_types[84]
2547 #define SWIGTYPE_p_wxJPEGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxKeyEvent swig_types[86]
2549 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[87]
2550 #define SWIGTYPE_p_wxLayoutConstraints swig_types[88]
2551 #define SWIGTYPE_p_wxMDIChildFrame swig_types[89]
2552 #define SWIGTYPE_p_wxMDIClientWindow swig_types[90]
2553 #define SWIGTYPE_p_wxMDIParentFrame swig_types[91]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenu swig_types[93]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[94]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[95]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[96]
2559 #define SWIGTYPE_p_wxMessageDialog swig_types[97]
2560 #define SWIGTYPE_p_wxMiniFrame swig_types[98]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMouseEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2564 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[102]
2565 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2567 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2568 #define SWIGTYPE_p_wxObject swig_types[106]
2569 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPageSetupDialog swig_types[110]
2573 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[111]
2574 #define SWIGTYPE_p_wxPaintEvent swig_types[112]
2575 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPanel swig_types[114]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[115]
2578 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[116]
2579 #define SWIGTYPE_p_wxPoint swig_types[117]
2580 #define SWIGTYPE_p_wxPopupWindow swig_types[118]
2581 #define SWIGTYPE_p_wxPreviewCanvas swig_types[119]
2582 #define SWIGTYPE_p_wxPreviewControlBar swig_types[120]
2583 #define SWIGTYPE_p_wxPreviewFrame swig_types[121]
2584 #define SWIGTYPE_p_wxPrintData swig_types[122]
2585 #define SWIGTYPE_p_wxPrintDialog swig_types[123]
2586 #define SWIGTYPE_p_wxPrintDialogData swig_types[124]
2587 #define SWIGTYPE_p_wxPrintPreview swig_types[125]
2588 #define SWIGTYPE_p_wxPrinter swig_types[126]
2589 #define SWIGTYPE_p_wxProgressDialog swig_types[127]
2590 #define SWIGTYPE_p_wxPyApp swig_types[128]
2591 #define SWIGTYPE_p_wxPyCommandEvent swig_types[129]
2592 #define SWIGTYPE_p_wxPyEvent swig_types[130]
2593 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[131]
2594 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[132]
2595 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[133]
2596 #define SWIGTYPE_p_wxPyGridTableBase swig_types[134]
2597 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[135]
2598 #define SWIGTYPE_p_wxPyImageHandler swig_types[136]
2599 #define SWIGTYPE_p_wxPyPanel swig_types[137]
2600 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[138]
2601 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[139]
2602 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[140]
2603 #define SWIGTYPE_p_wxPyPrintPreview swig_types[141]
2604 #define SWIGTYPE_p_wxPyPrintout swig_types[142]
2605 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[143]
2606 #define SWIGTYPE_p_wxPySizer swig_types[144]
2607 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[145]
2608 #define SWIGTYPE_p_wxPyVListBox swig_types[146]
2609 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[147]
2610 #define SWIGTYPE_p_wxPyValidator swig_types[148]
2611 #define SWIGTYPE_p_wxPyWindow swig_types[149]
2612 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[150]
2613 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[151]
2614 #define SWIGTYPE_p_wxRect swig_types[152]
2615 #define SWIGTYPE_p_wxSashEvent swig_types[153]
2616 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[154]
2617 #define SWIGTYPE_p_wxSashWindow swig_types[155]
2618 #define SWIGTYPE_p_wxScrollEvent swig_types[156]
2619 #define SWIGTYPE_p_wxScrollWinEvent swig_types[157]
2620 #define SWIGTYPE_p_wxScrolledWindow swig_types[158]
2621 #define SWIGTYPE_p_wxSetCursorEvent swig_types[159]
2622 #define SWIGTYPE_p_wxShowEvent swig_types[160]
2623 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[161]
2624 #define SWIGTYPE_p_wxSizeEvent swig_types[162]
2625 #define SWIGTYPE_p_wxSizer swig_types[163]
2626 #define SWIGTYPE_p_wxSizerItem swig_types[164]
2627 #define SWIGTYPE_p_wxSplashScreen swig_types[165]
2628 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[166]
2629 #define SWIGTYPE_p_wxSplitterEvent swig_types[167]
2630 #define SWIGTYPE_p_wxSplitterWindow swig_types[168]
2631 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[169]
2632 #define SWIGTYPE_p_wxStatusBar swig_types[170]
2633 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[171]
2634 #define SWIGTYPE_p_wxString swig_types[172]
2635 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[173]
2636 #define SWIGTYPE_p_wxTIFFHandler swig_types[174]
2637 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[175]
2638 #define SWIGTYPE_p_wxTextEntryDialog swig_types[176]
2639 #define SWIGTYPE_p_wxTipWindow swig_types[177]
2640 #define SWIGTYPE_p_wxTopLevelWindow swig_types[178]
2641 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[179]
2642 #define SWIGTYPE_p_wxValidator swig_types[180]
2643 #define SWIGTYPE_p_wxVisualAttributes swig_types[181]
2644 #define SWIGTYPE_p_wxWindow swig_types[182]
2645 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[183]
2646 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[184]
2647 #define SWIGTYPE_p_wxXPMHandler swig_types[185]
2648 static swig_type_info *swig_types[187];
2649 static swig_module_info swig_module = {swig_types, 186, 0, 0, 0, 0};
2650 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2651 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2652
2653 /* -------- TYPES TABLE (END) -------- */
2654
2655 #if (PY_VERSION_HEX <= 0x02000000)
2656 # if !defined(SWIG_PYTHON_CLASSIC)
2657 # error "This python version requires to use swig with the '-classic' option"
2658 # endif
2659 #endif
2660 #if (PY_VERSION_HEX <= 0x02020000)
2661 # error "This python version requires to use swig with the '-nomodern' option"
2662 #endif
2663 #if (PY_VERSION_HEX <= 0x02020000)
2664 # error "This python version requires to use swig with the '-nomodernargs' option"
2665 #endif
2666 #ifndef METH_O
2667 # error "This python version requires to use swig with the '-nofastunpack' option"
2668 #endif
2669
2670 /*-----------------------------------------------
2671 @(target):= _grid.so
2672 ------------------------------------------------*/
2673 #define SWIG_init init_grid
2674
2675 #define SWIG_name "_grid"
2676
2677 #define SWIGVERSION 0x010329
2678
2679
2680 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2681 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2682
2683
2684 #include <stdexcept>
2685
2686
2687 namespace swig {
2688 class PyObject_ptr {
2689 protected:
2690 PyObject *_obj;
2691
2692 public:
2693 PyObject_ptr() :_obj(0)
2694 {
2695 }
2696
2697 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2698 {
2699 Py_XINCREF(_obj);
2700 }
2701
2702 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2703 {
2704 if (initial_ref) Py_XINCREF(_obj);
2705 }
2706
2707 PyObject_ptr & operator=(const PyObject_ptr& item)
2708 {
2709 Py_XINCREF(item._obj);
2710 Py_XDECREF(_obj);
2711 _obj = item._obj;
2712 return *this;
2713 }
2714
2715 ~PyObject_ptr()
2716 {
2717 Py_XDECREF(_obj);
2718 }
2719
2720 operator PyObject *() const
2721 {
2722 return _obj;
2723 }
2724
2725 PyObject *operator->() const
2726 {
2727 return _obj;
2728 }
2729 };
2730 }
2731
2732
2733 namespace swig {
2734 struct PyObject_var : PyObject_ptr {
2735 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2736
2737 PyObject_var & operator = (PyObject* obj)
2738 {
2739 Py_XDECREF(_obj);
2740 _obj = obj;
2741 return *this;
2742 }
2743 };
2744 }
2745
2746
2747 #include "wx/wxPython/wxPython.h"
2748 #include "wx/wxPython/pyclasses.h"
2749 #include "wx/wxPython/printfw.h"
2750
2751 #include <wx/grid.h>
2752 #include <wx/generic/gridctrl.h>
2753
2754
2755 static const wxString wxPyEmptyString(wxEmptyString);
2756 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2757 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2758
2759
2760 #define wxPyMake_TEMPLATE(TYPE) \
2761 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2762 PyObject* target = NULL; \
2763 if (source) { \
2764 /* Check if there is already a pointer to a Python object in the \
2765 OOR data that we can use. */ \
2766 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2767 if (data) { \
2768 target = data->m_obj; \
2769 if (target) \
2770 Py_INCREF(target); \
2771 } \
2772 /* Otherwise make a new wrapper for it the old fashioned way and \
2773 give it the OOR treatment */ \
2774 if (! target) { \
2775 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2776 if (target) \
2777 source->SetClientObject(new wxPyOORClientData(target)); \
2778 } \
2779 } else { /* source was NULL so return None. */ \
2780 Py_INCREF(Py_None); target = Py_None; \
2781 } \
2782 return target; \
2783 } \
2784
2785
2786 wxPyMake_TEMPLATE(wxGridCellRenderer)
2787 wxPyMake_TEMPLATE(wxGridCellEditor)
2788 wxPyMake_TEMPLATE(wxGridCellAttr)
2789 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2790 wxPyMake_TEMPLATE(wxGridTableBase)
2791
2792
2793
2794 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2795 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2796 wxGridCellAttr* rval = NULL; \
2797 bool found; \
2798 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2799 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2800 PyObject* ro; \
2801 wxGridCellAttr* ptr; \
2802 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2803 if (ro) { \
2804 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2805 rval = ptr; \
2806 Py_DECREF(ro); \
2807 } \
2808 } \
2809 wxPyEndBlockThreads(blocked); \
2810 if (! found) \
2811 rval = PCLASS::CBNAME(a, b, c); \
2812 return rval; \
2813 }
2814
2815
2816 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2817 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2819 bool found; \
2820 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2821 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2822 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2823 Py_DECREF(obj); \
2824 } \
2825 wxPyEndBlockThreads(blocked); \
2826 if (! found) \
2827 PCLASS::CBNAME(attr, a, b); \
2828 }
2829
2830
2831
2832 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2833 void CBNAME(wxGridCellAttr *attr, int val) { \
2834 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2835 bool found; \
2836 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2837 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2838 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2839 Py_DECREF(obj); \
2840 } \
2841 wxPyEndBlockThreads(blocked); \
2842 if (! found) \
2843 PCLASS::CBNAME(attr, val); \
2844 }
2845
2846
2847
2848 #define PYCALLBACK_INT__pure(CBNAME) \
2849 int CBNAME() { \
2850 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2851 int rval = 0; \
2852 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2853 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2854 wxPyEndBlockThreads(blocked); \
2855 return rval; \
2856 }
2857
2858
2859
2860 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2861 bool CBNAME(int a, int b) { \
2862 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2863 bool rval = 0; \
2864 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2865 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2866 wxPyEndBlockThreads(blocked); \
2867 return rval; \
2868 }
2869
2870
2871 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2872 wxString CBNAME(int a, int b) { \
2873 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2874 wxString rval; \
2875 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2876 PyObject* ro; \
2877 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2878 if (ro) { \
2879 rval = Py2wxString(ro); \
2880 Py_DECREF(ro); \
2881 } \
2882 } \
2883 wxPyEndBlockThreads(blocked); \
2884 return rval; \
2885 }
2886
2887
2888 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2889 void CBNAME(int a, int b, const wxString& c) { \
2890 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2891 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2892 PyObject* s = wx2PyString(c); \
2893 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2894 Py_DECREF(s); \
2895 } \
2896 wxPyEndBlockThreads(blocked); \
2897 }
2898
2899
2900 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2901 wxString CBNAME(int a, int b) { \
2902 bool found; \
2903 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2904 wxString rval; \
2905 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2906 PyObject* ro; \
2907 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2908 if (ro) { \
2909 rval = Py2wxString(ro); \
2910 Py_DECREF(ro); \
2911 } \
2912 } \
2913 wxPyEndBlockThreads(blocked); \
2914 if (! found) \
2915 rval = PCLASS::CBNAME(a, b); \
2916 return rval; \
2917 }
2918
2919
2920 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2921 bool CBNAME(int a, int b, const wxString& c) { \
2922 bool rval = 0; \
2923 bool found; \
2924 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2925 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2926 PyObject* s = wx2PyString(c); \
2927 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2928 Py_DECREF(s); \
2929 } \
2930 wxPyEndBlockThreads(blocked); \
2931 if (! found) \
2932 rval = PCLASS::CBNAME(a,b,c); \
2933 return rval; \
2934 }
2935
2936
2937
2938
2939 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2940 long CBNAME(int a, int b) { \
2941 long rval; \
2942 bool found; \
2943 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2944 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2945 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2946 wxPyEndBlockThreads(blocked); \
2947 if (! found) \
2948 rval = PCLASS::CBNAME(a,b); \
2949 return rval; \
2950 }
2951
2952
2953 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2954 bool CBNAME(int a, int b) { \
2955 bool rval = 0; \
2956 bool found; \
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2958 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2959 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2960 wxPyEndBlockThreads(blocked); \
2961 if (! found) \
2962 rval = PCLASS::CBNAME(a,b); \
2963 return rval; \
2964 }
2965
2966
2967
2968 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2969 double CBNAME(int a, int b) { \
2970 bool found; \
2971 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2972 double rval; \
2973 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2974 PyObject* ro; \
2975 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2976 if (ro) { \
2977 PyObject* str = PyObject_Str(ro); \
2978 rval = PyFloat_AsDouble(str); \
2979 Py_DECREF(ro); Py_DECREF(str); \
2980 } \
2981 } \
2982 wxPyEndBlockThreads(blocked); \
2983 if (! found) \
2984 rval = PCLASS::CBNAME(a, b); \
2985 return rval; \
2986 }
2987
2988
2989
2990 #define PYCALLBACK__(PCLASS, CBNAME) \
2991 void CBNAME() { \
2992 bool found; \
2993 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2994 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2995 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2996 wxPyEndBlockThreads(blocked); \
2997 if (! found) \
2998 PCLASS::CBNAME(); \
2999 }
3000
3001
3002
3003 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3004 bool CBNAME(size_t a, size_t b) { \
3005 bool rval = 0; \
3006 bool found; \
3007 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3008 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3009 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3010 wxPyEndBlockThreads(blocked); \
3011 if (! found) \
3012 rval = PCLASS::CBNAME(a,b); \
3013 return rval; \
3014 }
3015
3016
3017
3018 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3019 bool CBNAME(size_t a) { \
3020 bool rval = 0; \
3021 bool found; \
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3023 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3024 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3025 wxPyEndBlockThreads(blocked); \
3026 if (! found) \
3027 rval = PCLASS::CBNAME(a); \
3028 return rval; \
3029 }
3030
3031
3032 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3033 wxString CBNAME(int a) { \
3034 bool found; \
3035 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3036 wxString rval; \
3037 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3038 PyObject* ro; \
3039 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3040 if (ro) { \
3041 rval = Py2wxString(ro); \
3042 Py_DECREF(ro); \
3043 } \
3044 } \
3045 wxPyEndBlockThreads(blocked); \
3046 if (! found) \
3047 rval = PCLASS::CBNAME(a); \
3048 return rval; \
3049 }
3050
3051
3052 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3053 void CBNAME(int a, const wxString& c) { \
3054 bool found; \
3055 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3056 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3057 PyObject* s = wx2PyString(c); \
3058 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3059 Py_DECREF(s); \
3060 } \
3061 wxPyEndBlockThreads(blocked); \
3062 if (! found) \
3063 PCLASS::CBNAME(a,c); \
3064 }
3065
3066
3067
3068
3069 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3070 bool CBNAME() { \
3071 bool rval = 0; \
3072 bool found; \
3073 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3074 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3075 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3076 wxPyEndBlockThreads(blocked); \
3077 if (! found) \
3078 rval = PCLASS::CBNAME(); \
3079 return rval; \
3080 }
3081
3082
3083
3084 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3085 void CBNAME(size_t a, int b) { \
3086 bool found; \
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3088 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3089 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3090 wxPyEndBlockThreads(blocked); \
3091 if (! found) \
3092 PCLASS::CBNAME(a,b); \
3093 }
3094
3095
3096
3097
3098 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3099 void CBNAME(int a, int b, long c) { \
3100 bool found; \
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3102 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3103 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3104 wxPyEndBlockThreads(blocked); \
3105 if (! found) \
3106 PCLASS::CBNAME(a,b,c); \
3107 }
3108
3109
3110
3111
3112 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3113 void CBNAME(int a, int b, double c) { \
3114 bool found; \
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3116 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3117 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3118 wxPyEndBlockThreads(blocked); \
3119 if (! found) \
3120 PCLASS::CBNAME(a,b,c); \
3121 }
3122
3123
3124
3125 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3126 void CBNAME(int a, int b, bool c) { \
3127 bool found; \
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3129 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3130 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3131 wxPyEndBlockThreads(blocked); \
3132 if (! found) \
3133 PCLASS::CBNAME(a,b,c); \
3134 }
3135
3136
3137
3138
3139
3140 SWIGINTERN swig_type_info*
3141 SWIG_pchar_descriptor()
3142 {
3143 static int init = 0;
3144 static swig_type_info* info = 0;
3145 if (!init) {
3146 info = SWIG_TypeQuery("_p_char");
3147 init = 1;
3148 }
3149 return info;
3150 }
3151
3152
3153 SWIGINTERNINLINE PyObject *
3154 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3155 {
3156 if (carray) {
3157 if (size > INT_MAX) {
3158 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3159 return pchar_descriptor ?
3160 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3161 } else {
3162 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3163 }
3164 } else {
3165 return SWIG_Py_Void();
3166 }
3167 }
3168
3169
3170 SWIGINTERNINLINE PyObject *
3171 SWIG_FromCharPtr(const char *cptr)
3172 {
3173 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3174 }
3175
3176
3177 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3178 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3179 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3180 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3181 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3182 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3183 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3184 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3185 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3186 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3187
3188
3189 #define SWIG_From_long PyInt_FromLong
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_From_int (int value)
3194 {
3195 return SWIG_From_long (value);
3196 }
3197
3198 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3199 if (!self->GetClientObject())
3200 self->SetClientObject(new wxPyOORClientData(_self));
3201 }
3202 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3203 }
3204
3205 class wxPyGridCellRenderer : public wxGridCellRenderer
3206 {
3207 public:
3208 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3209
3210 // Implement Python callback aware virtual methods
3211 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3212 wxDC& dc, const wxRect& rect,
3213 int row, int col, bool isSelected) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3216 PyObject* go = wxPyMake_wxObject(&grid,false);
3217 PyObject* dco = wxPyMake_wxObject(&dc,false);
3218 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3219 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3220
3221 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3222 row, col, isSelected));
3223 Py_DECREF(go);
3224 Py_DECREF(ao);
3225 Py_DECREF(dco);
3226 Py_DECREF(ro);
3227 }
3228 wxPyEndBlockThreads(blocked);
3229 }
3230
3231 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3232 int row, int col) {
3233 wxSize rval;
3234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3235 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3236 PyObject* ro;
3237 wxSize* ptr;
3238 PyObject* go = wxPyMake_wxObject(&grid,false);
3239 PyObject* dco = wxPyMake_wxObject(&dc,false);
3240 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3241
3242 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3243 go, ao, dco,
3244 row, col));
3245 Py_DECREF(go);
3246 Py_DECREF(ao);
3247 Py_DECREF(dco);
3248
3249 if (ro) {
3250 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3251 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3252 rval = *ptr;
3253 }
3254 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3255 PyObject* o1 = PySequence_GetItem(ro, 0);
3256 PyObject* o2 = PySequence_GetItem(ro, 1);
3257 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3258 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3259 else
3260 PyErr_SetString(PyExc_TypeError, errmsg);
3261 Py_DECREF(o1);
3262 Py_DECREF(o2);
3263 }
3264 else {
3265 PyErr_SetString(PyExc_TypeError, errmsg);
3266 }
3267 Py_DECREF(ro);
3268 }
3269 }
3270 wxPyEndBlockThreads(blocked);
3271 return rval;
3272 }
3273
3274
3275 wxGridCellRenderer *Clone() const {
3276 wxGridCellRenderer* rval = NULL;
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3279 PyObject* ro;
3280 wxGridCellRenderer* ptr;
3281 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3282 if (ro) {
3283 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3284 rval = ptr;
3285 Py_DECREF(ro);
3286 }
3287 }
3288 wxPyEndBlockThreads(blocked);
3289 return rval;
3290 }
3291
3292 DEC_PYCALLBACK__STRING(SetParameters);
3293
3294 PYPRIVATE;
3295 };
3296
3297 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3298
3299
3300
3301 #include <limits.h>
3302 #ifndef LLONG_MIN
3303 # define LLONG_MIN LONG_LONG_MIN
3304 #endif
3305 #ifndef LLONG_MAX
3306 # define LLONG_MAX LONG_LONG_MAX
3307 #endif
3308 #ifndef ULLONG_MAX
3309 # define ULLONG_MAX ULONG_LONG_MAX
3310 #endif
3311
3312
3313 SWIGINTERN int
3314 SWIG_AsVal_long (PyObject* obj, long* val)
3315 {
3316 if (PyNumber_Check(obj)) {
3317 if (val) *val = PyInt_AsLong(obj);
3318 return SWIG_OK;
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsVal_int (PyObject * obj, int *val)
3326 {
3327 long v;
3328 int res = SWIG_AsVal_long (obj, &v);
3329 if (SWIG_IsOK(res)) {
3330 if ((v < INT_MIN || v > INT_MAX)) {
3331 return SWIG_OverflowError;
3332 } else {
3333 if (val) *val = static_cast< int >(v);
3334 }
3335 }
3336 return res;
3337 }
3338
3339
3340 SWIGINTERN int
3341 SWIG_AsVal_bool (PyObject *obj, bool *val)
3342 {
3343 if (obj == Py_True) {
3344 if (val) *val = true;
3345 return SWIG_OK;
3346 } else if (obj == Py_False) {
3347 if (val) *val = false;
3348 return SWIG_OK;
3349 } else {
3350 long v = 0;
3351 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3352 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3353 return res;
3354 }
3355 }
3356
3357
3358 class wxPyGridCellEditor : public wxGridCellEditor
3359 {
3360 public:
3361 wxPyGridCellEditor() : wxGridCellEditor() {}
3362
3363 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3364 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3365 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3366 PyObject* po = wxPyMake_wxObject(parent,false);
3367 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3368
3369 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3370 Py_DECREF(po);
3371 Py_DECREF(eo);
3372 }
3373 wxPyEndBlockThreads(blocked);
3374 }
3375
3376
3377 void BeginEdit(int row, int col, wxGrid* grid) {
3378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3379 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3380 PyObject* go = wxPyMake_wxObject(grid,false);
3381 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3382 Py_DECREF(go);
3383 }
3384 wxPyEndBlockThreads(blocked);
3385 }
3386
3387
3388 bool EndEdit(int row, int col, wxGrid* grid) {
3389 bool rv = false;
3390 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3391 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3392 PyObject* go = wxPyMake_wxObject(grid,false);
3393 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3394 Py_DECREF(go);
3395 }
3396 wxPyEndBlockThreads(blocked);
3397 return rv;
3398 }
3399
3400
3401 wxGridCellEditor* Clone() const {
3402 wxGridCellEditor* rval = NULL;
3403 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3404 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3405 PyObject* ro;
3406 wxGridCellEditor* ptr;
3407 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3408 if (ro) {
3409 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3410 rval = ptr;
3411 Py_DECREF(ro);
3412 }
3413 }
3414 wxPyEndBlockThreads(blocked);
3415 return rval;
3416 }
3417
3418
3419 void Show(bool show, wxGridCellAttr *attr) {
3420 bool found;
3421 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3422 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3423 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3424 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3425 Py_DECREF(ao);
3426 }
3427 wxPyEndBlockThreads(blocked);
3428 if (! found)
3429 wxGridCellEditor::Show(show, attr);
3430 }
3431
3432
3433 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3434 bool found;
3435 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3436 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3437 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3438 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3439
3440 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3441
3442 Py_DECREF(ro);
3443 Py_DECREF(ao);
3444 }
3445 wxPyEndBlockThreads(blocked);
3446 if (! found)
3447 wxGridCellEditor::PaintBackground(rectCell, attr);
3448 }
3449
3450
3451 DEC_PYCALLBACK___pure(Reset);
3452 DEC_PYCALLBACK__constany(SetSize, wxRect);
3453 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3454 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3455 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3456 DEC_PYCALLBACK__(StartingClick);
3457 DEC_PYCALLBACK__(Destroy);
3458 DEC_PYCALLBACK__STRING(SetParameters);
3459 DEC_PYCALLBACK_STRING__constpure(GetValue);
3460
3461 PYPRIVATE;
3462 };
3463
3464
3465 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3466 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3467 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3468 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3469 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3470 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3471 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3472 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3473 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3474
3475
3476 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3477 if (!self->GetClientObject())
3478 self->SetClientObject(new wxPyOORClientData(_self));
3479 }
3480 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3481 }
3482 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3483 if (!self->GetClientObject())
3484 self->SetClientObject(new wxPyOORClientData(_self));
3485 }
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3489 {
3490 long v = 0;
3491 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3492 return SWIG_TypeError;
3493 }
3494 else if (val)
3495 *val = (unsigned long)v;
3496 return SWIG_OK;
3497 }
3498
3499
3500 SWIGINTERNINLINE int
3501 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3502 {
3503 unsigned long v;
3504 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3505 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3506 return res;
3507 }
3508
3509
3510 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3511 {
3512 public:
3513 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3514
3515 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3516 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3517 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3518 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3519
3520 PYPRIVATE;
3521 };
3522
3523 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3524 if (!self->GetClientObject())
3525 self->SetClientObject(new wxPyOORClientData(_self));
3526 }
3527
3528 #define SWIG_From_double PyFloat_FromDouble
3529
3530
3531 SWIGINTERN int
3532 SWIG_AsVal_double (PyObject *obj, double* val)
3533 {
3534 if (PyNumber_Check(obj)) {
3535 if (val) *val = PyFloat_AsDouble(obj);
3536 return SWIG_OK;
3537 }
3538 return SWIG_TypeError;
3539 }
3540
3541
3542 class wxPyGridTableBase : public wxGridTableBase
3543 {
3544 public:
3545 wxPyGridTableBase() : wxGridTableBase() {}
3546
3547 PYCALLBACK_INT__pure(GetNumberRows);
3548 PYCALLBACK_INT__pure(GetNumberCols);
3549 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3550 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3551 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3552 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3553 PYCALLBACK__(wxGridTableBase, Clear);
3554 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3555 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3556 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3557 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3558 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3559 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3560 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3561 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3562 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3563 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3564 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3565 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3566 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3567 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3568 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3569
3570
3571 wxString GetValue(int row, int col) {
3572 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3573 wxString rval;
3574 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3575 PyObject* ro;
3576 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3577 if (ro) {
3578 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3579 PyObject* old = ro;
3580 ro = PyObject_Str(ro);
3581 Py_DECREF(old);
3582 }
3583 rval = Py2wxString(ro);
3584 Py_DECREF(ro);
3585 }
3586 }
3587 wxPyEndBlockThreads(blocked);
3588 return rval;
3589 }
3590
3591 void SetValue(int row, int col, const wxString& val) {
3592 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3593 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3594 PyObject* s = wx2PyString(val);
3595 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3596 Py_DECREF(s);
3597 }
3598 wxPyEndBlockThreads(blocked);
3599 }
3600
3601
3602 // Map the Get/Set methods for the standard non-string types to
3603 // the GetValue and SetValue python methods.
3604 long GetValueAsLong( int row, int col ) {
3605 long rval = 0;
3606 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3607 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3608 PyObject* ro;
3609 PyObject* num;
3610 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3611 if (ro && PyNumber_Check(ro)) {
3612 num = PyNumber_Int(ro);
3613 if (num) {
3614 rval = PyInt_AsLong(num);
3615 Py_DECREF(num);
3616 }
3617 Py_DECREF(ro);
3618 }
3619 }
3620 wxPyEndBlockThreads(blocked);
3621 return rval;
3622 }
3623
3624 double GetValueAsDouble( int row, int col ) {
3625 double rval = 0.0;
3626 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3627 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3628 PyObject* ro;
3629 PyObject* num;
3630 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3631 if (ro && PyNumber_Check(ro)) {
3632 num = PyNumber_Float(ro);
3633 if (num) {
3634 rval = PyFloat_AsDouble(num);
3635 Py_DECREF(num);
3636 }
3637 Py_DECREF(ro);
3638 }
3639 }
3640 wxPyEndBlockThreads(blocked);
3641 return rval;
3642 }
3643
3644 bool GetValueAsBool( int row, int col ) {
3645 return (bool)GetValueAsLong(row, col);
3646 }
3647
3648 void SetValueAsLong( int row, int col, long value ) {
3649 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3650 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3651 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3652 }
3653 wxPyEndBlockThreads(blocked);
3654 }
3655
3656 void SetValueAsDouble( int row, int col, double value ) {
3657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3658 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3659 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3660 }
3661 wxPyEndBlockThreads(blocked);
3662 }
3663
3664 void SetValueAsBool( int row, int col, bool value ) {
3665 SetValueAsLong( row, col, (long)value );
3666 }
3667
3668
3669 PYPRIVATE;
3670 };
3671
3672 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3673
3674 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3675
3676 if (source == Py_None) {
3677 **obj = wxGridCellCoords(-1,-1);
3678 return true;
3679 }
3680
3681 // If source is an object instance then it may already be the right type
3682 if (wxPySwigInstance_Check(source)) {
3683 wxGridCellCoords* ptr;
3684 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3685 goto error;
3686 *obj = ptr;
3687 return true;
3688 }
3689 // otherwise a 2-tuple of integers is expected
3690 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3691 PyObject* o1 = PySequence_GetItem(source, 0);
3692 PyObject* o2 = PySequence_GetItem(source, 1);
3693 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3694 Py_DECREF(o1);
3695 Py_DECREF(o2);
3696 goto error;
3697 }
3698 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3699 Py_DECREF(o1);
3700 Py_DECREF(o2);
3701 return true;
3702 }
3703
3704 error:
3705 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3706 return false;
3707 }
3708
3709
3710 bool wxGridCellCoords_typecheck(PyObject* source) {
3711 void* ptr;
3712
3713 if (wxPySwigInstance_Check(source) &&
3714 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3715 return true;
3716
3717 PyErr_Clear();
3718 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3719 return true;
3720
3721 return false;
3722 }
3723
3724
3725 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3726 {
3727 PyObject* list = PyList_New(0);
3728 size_t idx;
3729 for (idx = 0; idx < source.GetCount(); idx += 1) {
3730 wxGridCellCoords& coord = source.Item(idx);
3731 PyObject* tup = PyTuple_New(2);
3732 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3733 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3734 PyList_Append(list, tup);
3735 Py_DECREF(tup);
3736 }
3737 return list;
3738 }
3739
3740 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3741 PyObject* tup = PyTuple_New(2);
3742 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3743 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3744 return tup;
3745 }
3746
3747 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3748
3749 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3750 wxGridCellCoords rv;
3751 self->XYToCell(x, y, rv);
3752 return rv;
3753 }
3754 #ifdef __cplusplus
3755 extern "C" {
3756 #endif
3757 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3758 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3759 return 1;
3760 }
3761
3762
3763 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3764 PyObject *pyobj = 0;
3765
3766 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3767 return pyobj;
3768 }
3769
3770
3771 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3772 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3773 return 1;
3774 }
3775
3776
3777 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3778 PyObject *pyobj = 0;
3779
3780 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3781 return pyobj;
3782 }
3783
3784
3785 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj = 0;
3787 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3788 PyObject *arg2 = (PyObject *) 0 ;
3789 void *argp1 = 0 ;
3790 int res1 = 0 ;
3791 PyObject * obj0 = 0 ;
3792 PyObject * obj1 = 0 ;
3793 char * kwnames[] = {
3794 (char *) "self",(char *) "_self", NULL
3795 };
3796
3797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3799 if (!SWIG_IsOK(res1)) {
3800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3801 }
3802 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3803 arg2 = obj1;
3804 {
3805 PyThreadState* __tstate = wxPyBeginAllowThreads();
3806 wxGridCellWorker__setOORInfo(arg1,arg2);
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 resultobj = SWIG_Py_Void();
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3818 PyObject *resultobj = 0;
3819 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3820 void *argp1 = 0 ;
3821 int res1 = 0 ;
3822 PyObject *swig_obj[1] ;
3823
3824 if (!args) SWIG_fail;
3825 swig_obj[0] = args;
3826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3827 if (!SWIG_IsOK(res1)) {
3828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3829 }
3830 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 delete_wxGridCellWorker(arg1);
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 resultobj = SWIG_Py_Void();
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj = 0;
3847 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3848 wxString *arg2 = 0 ;
3849 void *argp1 = 0 ;
3850 int res1 = 0 ;
3851 bool temp2 = false ;
3852 PyObject * obj0 = 0 ;
3853 PyObject * obj1 = 0 ;
3854 char * kwnames[] = {
3855 (char *) "self",(char *) "params", NULL
3856 };
3857
3858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3860 if (!SWIG_IsOK(res1)) {
3861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3862 }
3863 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3864 {
3865 arg2 = wxString_in_helper(obj1);
3866 if (arg2 == NULL) SWIG_fail;
3867 temp2 = true;
3868 }
3869 {
3870 PyThreadState* __tstate = wxPyBeginAllowThreads();
3871 (arg1)->SetParameters((wxString const &)*arg2);
3872 wxPyEndAllowThreads(__tstate);
3873 if (PyErr_Occurred()) SWIG_fail;
3874 }
3875 resultobj = SWIG_Py_Void();
3876 {
3877 if (temp2)
3878 delete arg2;
3879 }
3880 return resultobj;
3881 fail:
3882 {
3883 if (temp2)
3884 delete arg2;
3885 }
3886 return NULL;
3887 }
3888
3889
3890 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3891 PyObject *resultobj = 0;
3892 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3893 void *argp1 = 0 ;
3894 int res1 = 0 ;
3895 PyObject *swig_obj[1] ;
3896
3897 if (!args) SWIG_fail;
3898 swig_obj[0] = args;
3899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3900 if (!SWIG_IsOK(res1)) {
3901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3902 }
3903 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3904 {
3905 PyThreadState* __tstate = wxPyBeginAllowThreads();
3906 (arg1)->IncRef();
3907 wxPyEndAllowThreads(__tstate);
3908 if (PyErr_Occurred()) SWIG_fail;
3909 }
3910 resultobj = SWIG_Py_Void();
3911 return resultobj;
3912 fail:
3913 return NULL;
3914 }
3915
3916
3917 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3918 PyObject *resultobj = 0;
3919 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3920 void *argp1 = 0 ;
3921 int res1 = 0 ;
3922 PyObject *swig_obj[1] ;
3923
3924 if (!args) SWIG_fail;
3925 swig_obj[0] = args;
3926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3927 if (!SWIG_IsOK(res1)) {
3928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3929 }
3930 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 (arg1)->DecRef();
3934 wxPyEndAllowThreads(__tstate);
3935 if (PyErr_Occurred()) SWIG_fail;
3936 }
3937 resultobj = SWIG_Py_Void();
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3945 PyObject *obj;
3946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3947 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3948 return SWIG_Py_Void();
3949 }
3950
3951 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3952 PyObject *obj;
3953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3954 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3955 return SWIG_Py_Void();
3956 }
3957
3958 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3959 PyObject *resultobj = 0;
3960 wxPyGridCellRenderer *result = 0 ;
3961
3962 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3963 {
3964 PyThreadState* __tstate = wxPyBeginAllowThreads();
3965 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3966 wxPyEndAllowThreads(__tstate);
3967 if (PyErr_Occurred()) SWIG_fail;
3968 }
3969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3970 return resultobj;
3971 fail:
3972 return NULL;
3973 }
3974
3975
3976 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3977 PyObject *resultobj = 0;
3978 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3979 PyObject *arg2 = (PyObject *) 0 ;
3980 PyObject *arg3 = (PyObject *) 0 ;
3981 void *argp1 = 0 ;
3982 int res1 = 0 ;
3983 PyObject * obj0 = 0 ;
3984 PyObject * obj1 = 0 ;
3985 PyObject * obj2 = 0 ;
3986 char * kwnames[] = {
3987 (char *) "self",(char *) "self",(char *) "_class", NULL
3988 };
3989
3990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
3992 if (!SWIG_IsOK(res1)) {
3993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
3994 }
3995 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
3996 arg2 = obj1;
3997 arg3 = obj2;
3998 {
3999 PyThreadState* __tstate = wxPyBeginAllowThreads();
4000 (arg1)->_setCallbackInfo(arg2,arg3);
4001 wxPyEndAllowThreads(__tstate);
4002 if (PyErr_Occurred()) SWIG_fail;
4003 }
4004 resultobj = SWIG_Py_Void();
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj = 0;
4013 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4014 wxString *arg2 = 0 ;
4015 void *argp1 = 0 ;
4016 int res1 = 0 ;
4017 bool temp2 = false ;
4018 PyObject * obj0 = 0 ;
4019 PyObject * obj1 = 0 ;
4020 char * kwnames[] = {
4021 (char *) "self",(char *) "params", NULL
4022 };
4023
4024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4026 if (!SWIG_IsOK(res1)) {
4027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4028 }
4029 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4030 {
4031 arg2 = wxString_in_helper(obj1);
4032 if (arg2 == NULL) SWIG_fail;
4033 temp2 = true;
4034 }
4035 {
4036 PyThreadState* __tstate = wxPyBeginAllowThreads();
4037 (arg1)->SetParameters((wxString const &)*arg2);
4038 wxPyEndAllowThreads(__tstate);
4039 if (PyErr_Occurred()) SWIG_fail;
4040 }
4041 resultobj = SWIG_Py_Void();
4042 {
4043 if (temp2)
4044 delete arg2;
4045 }
4046 return resultobj;
4047 fail:
4048 {
4049 if (temp2)
4050 delete arg2;
4051 }
4052 return NULL;
4053 }
4054
4055
4056 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4057 PyObject *obj;
4058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4060 return SWIG_Py_Void();
4061 }
4062
4063 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4064 return SWIG_Python_InitShadowInstance(args);
4065 }
4066
4067 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4068 PyObject *resultobj = 0;
4069 wxGridCellStringRenderer *result = 0 ;
4070
4071 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4072 {
4073 PyThreadState* __tstate = wxPyBeginAllowThreads();
4074 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4075 wxPyEndAllowThreads(__tstate);
4076 if (PyErr_Occurred()) SWIG_fail;
4077 }
4078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4079 return resultobj;
4080 fail:
4081 return NULL;
4082 }
4083
4084
4085 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4086 PyObject *obj;
4087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4088 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4089 return SWIG_Py_Void();
4090 }
4091
4092 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4093 return SWIG_Python_InitShadowInstance(args);
4094 }
4095
4096 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4097 PyObject *resultobj = 0;
4098 wxGridCellNumberRenderer *result = 0 ;
4099
4100 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4101 {
4102 PyThreadState* __tstate = wxPyBeginAllowThreads();
4103 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4104 wxPyEndAllowThreads(__tstate);
4105 if (PyErr_Occurred()) SWIG_fail;
4106 }
4107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4115 PyObject *obj;
4116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4117 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4118 return SWIG_Py_Void();
4119 }
4120
4121 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4122 return SWIG_Python_InitShadowInstance(args);
4123 }
4124
4125 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 int arg1 = (int) -1 ;
4128 int arg2 = (int) -1 ;
4129 wxGridCellFloatRenderer *result = 0 ;
4130 int val1 ;
4131 int ecode1 = 0 ;
4132 int val2 ;
4133 int ecode2 = 0 ;
4134 PyObject * obj0 = 0 ;
4135 PyObject * obj1 = 0 ;
4136 char * kwnames[] = {
4137 (char *) "width",(char *) "precision", NULL
4138 };
4139
4140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4141 if (obj0) {
4142 ecode1 = SWIG_AsVal_int(obj0, &val1);
4143 if (!SWIG_IsOK(ecode1)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4145 }
4146 arg1 = static_cast< int >(val1);
4147 }
4148 if (obj1) {
4149 ecode2 = SWIG_AsVal_int(obj1, &val2);
4150 if (!SWIG_IsOK(ecode2)) {
4151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4152 }
4153 arg2 = static_cast< int >(val2);
4154 }
4155 {
4156 PyThreadState* __tstate = wxPyBeginAllowThreads();
4157 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4169 PyObject *resultobj = 0;
4170 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4171 int result;
4172 void *argp1 = 0 ;
4173 int res1 = 0 ;
4174 PyObject *swig_obj[1] ;
4175
4176 if (!args) SWIG_fail;
4177 swig_obj[0] = args;
4178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4179 if (!SWIG_IsOK(res1)) {
4180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4181 }
4182 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4183 {
4184 PyThreadState* __tstate = wxPyBeginAllowThreads();
4185 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 resultobj = SWIG_From_int(static_cast< int >(result));
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4197 PyObject *resultobj = 0;
4198 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4199 int arg2 ;
4200 void *argp1 = 0 ;
4201 int res1 = 0 ;
4202 int val2 ;
4203 int ecode2 = 0 ;
4204 PyObject * obj0 = 0 ;
4205 PyObject * obj1 = 0 ;
4206 char * kwnames[] = {
4207 (char *) "self",(char *) "width", NULL
4208 };
4209
4210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4212 if (!SWIG_IsOK(res1)) {
4213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4214 }
4215 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4216 ecode2 = SWIG_AsVal_int(obj1, &val2);
4217 if (!SWIG_IsOK(ecode2)) {
4218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4219 }
4220 arg2 = static_cast< int >(val2);
4221 {
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 (arg1)->SetWidth(arg2);
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 resultobj = SWIG_Py_Void();
4228 return resultobj;
4229 fail:
4230 return NULL;
4231 }
4232
4233
4234 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4235 PyObject *resultobj = 0;
4236 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4237 int result;
4238 void *argp1 = 0 ;
4239 int res1 = 0 ;
4240 PyObject *swig_obj[1] ;
4241
4242 if (!args) SWIG_fail;
4243 swig_obj[0] = args;
4244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4245 if (!SWIG_IsOK(res1)) {
4246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4247 }
4248 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4252 wxPyEndAllowThreads(__tstate);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 resultobj = SWIG_From_int(static_cast< int >(result));
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj = 0;
4264 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4265 int arg2 ;
4266 void *argp1 = 0 ;
4267 int res1 = 0 ;
4268 int val2 ;
4269 int ecode2 = 0 ;
4270 PyObject * obj0 = 0 ;
4271 PyObject * obj1 = 0 ;
4272 char * kwnames[] = {
4273 (char *) "self",(char *) "precision", NULL
4274 };
4275
4276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4278 if (!SWIG_IsOK(res1)) {
4279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4280 }
4281 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4282 ecode2 = SWIG_AsVal_int(obj1, &val2);
4283 if (!SWIG_IsOK(ecode2)) {
4284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4285 }
4286 arg2 = static_cast< int >(val2);
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 (arg1)->SetPrecision(arg2);
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 resultobj = SWIG_Py_Void();
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *obj;
4302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4303 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4304 return SWIG_Py_Void();
4305 }
4306
4307 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 return SWIG_Python_InitShadowInstance(args);
4309 }
4310
4311 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4312 PyObject *resultobj = 0;
4313 wxGridCellBoolRenderer *result = 0 ;
4314
4315 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330 PyObject *obj;
4331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4332 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4333 return SWIG_Py_Void();
4334 }
4335
4336 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 return SWIG_Python_InitShadowInstance(args);
4338 }
4339
4340 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj = 0;
4342 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4343 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4344 wxGridCellDateTimeRenderer *result = 0 ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 char * kwnames[] = {
4348 (char *) "outformat",(char *) "informat", NULL
4349 };
4350
4351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4352 if (obj0) {
4353 {
4354 wxString* sptr = wxString_in_helper(obj0);
4355 if (sptr == NULL) SWIG_fail;
4356 arg1 = *sptr;
4357 delete sptr;
4358 }
4359 }
4360 if (obj1) {
4361 {
4362 wxString* sptr = wxString_in_helper(obj1);
4363 if (sptr == NULL) SWIG_fail;
4364 arg2 = *sptr;
4365 delete sptr;
4366 }
4367 }
4368 {
4369 PyThreadState* __tstate = wxPyBeginAllowThreads();
4370 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4371 wxPyEndAllowThreads(__tstate);
4372 if (PyErr_Occurred()) SWIG_fail;
4373 }
4374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4375 return resultobj;
4376 fail:
4377 return NULL;
4378 }
4379
4380
4381 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4382 PyObject *obj;
4383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4384 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4385 return SWIG_Py_Void();
4386 }
4387
4388 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4389 return SWIG_Python_InitShadowInstance(args);
4390 }
4391
4392 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj = 0;
4394 wxString const &arg1_defvalue = wxPyEmptyString ;
4395 wxString *arg1 = (wxString *) &arg1_defvalue ;
4396 wxGridCellEnumRenderer *result = 0 ;
4397 bool temp1 = false ;
4398 PyObject * obj0 = 0 ;
4399 char * kwnames[] = {
4400 (char *) "choices", NULL
4401 };
4402
4403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4404 if (obj0) {
4405 {
4406 arg1 = wxString_in_helper(obj0);
4407 if (arg1 == NULL) SWIG_fail;
4408 temp1 = true;
4409 }
4410 }
4411 {
4412 PyThreadState* __tstate = wxPyBeginAllowThreads();
4413 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4414 wxPyEndAllowThreads(__tstate);
4415 if (PyErr_Occurred()) SWIG_fail;
4416 }
4417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4418 {
4419 if (temp1)
4420 delete arg1;
4421 }
4422 return resultobj;
4423 fail:
4424 {
4425 if (temp1)
4426 delete arg1;
4427 }
4428 return NULL;
4429 }
4430
4431
4432 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4433 PyObject *obj;
4434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4435 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4436 return SWIG_Py_Void();
4437 }
4438
4439 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4440 return SWIG_Python_InitShadowInstance(args);
4441 }
4442
4443 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4444 PyObject *resultobj = 0;
4445 wxGridCellAutoWrapStringRenderer *result = 0 ;
4446
4447 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4448 {
4449 PyThreadState* __tstate = wxPyBeginAllowThreads();
4450 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4451 wxPyEndAllowThreads(__tstate);
4452 if (PyErr_Occurred()) SWIG_fail;
4453 }
4454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4455 return resultobj;
4456 fail:
4457 return NULL;
4458 }
4459
4460
4461 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *obj;
4463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4464 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4465 return SWIG_Py_Void();
4466 }
4467
4468 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4469 return SWIG_Python_InitShadowInstance(args);
4470 }
4471
4472 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4473 PyObject *resultobj = 0;
4474 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4475 bool result;
4476 void *argp1 = 0 ;
4477 int res1 = 0 ;
4478 PyObject *swig_obj[1] ;
4479
4480 if (!args) SWIG_fail;
4481 swig_obj[0] = args;
4482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4483 if (!SWIG_IsOK(res1)) {
4484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4485 }
4486 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (bool)(arg1)->IsCreated();
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 {
4494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4495 }
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4503 PyObject *resultobj = 0;
4504 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4505 wxControl *result = 0 ;
4506 void *argp1 = 0 ;
4507 int res1 = 0 ;
4508 PyObject *swig_obj[1] ;
4509
4510 if (!args) SWIG_fail;
4511 swig_obj[0] = args;
4512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4513 if (!SWIG_IsOK(res1)) {
4514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4515 }
4516 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (wxControl *)(arg1)->GetControl();
4520 wxPyEndAllowThreads(__tstate);
4521 if (PyErr_Occurred()) SWIG_fail;
4522 }
4523 {
4524 resultobj = wxPyMake_wxObject(result, 0);
4525 }
4526 return resultobj;
4527 fail:
4528 return NULL;
4529 }
4530
4531
4532 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4533 PyObject *resultobj = 0;
4534 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4535 wxControl *arg2 = (wxControl *) 0 ;
4536 void *argp1 = 0 ;
4537 int res1 = 0 ;
4538 void *argp2 = 0 ;
4539 int res2 = 0 ;
4540 PyObject * obj0 = 0 ;
4541 PyObject * obj1 = 0 ;
4542 char * kwnames[] = {
4543 (char *) "self",(char *) "control", NULL
4544 };
4545
4546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4550 }
4551 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4553 if (!SWIG_IsOK(res2)) {
4554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4555 }
4556 arg2 = reinterpret_cast< wxControl * >(argp2);
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 (arg1)->SetControl(arg2);
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 resultobj = SWIG_Py_Void();
4564 return resultobj;
4565 fail:
4566 return NULL;
4567 }
4568
4569
4570 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571 PyObject *resultobj = 0;
4572 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4573 wxGridCellAttr *result = 0 ;
4574 void *argp1 = 0 ;
4575 int res1 = 0 ;
4576 PyObject *swig_obj[1] ;
4577
4578 if (!args) SWIG_fail;
4579 swig_obj[0] = args;
4580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4581 if (!SWIG_IsOK(res1)) {
4582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4583 }
4584 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 {
4592 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj = 0;
4602 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4603 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 void *argp2 = 0 ;
4607 int res2 = 0 ;
4608 PyObject * obj0 = 0 ;
4609 PyObject * obj1 = 0 ;
4610 char * kwnames[] = {
4611 (char *) "self",(char *) "attr", NULL
4612 };
4613
4614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4618 }
4619 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4621 if (!SWIG_IsOK(res2)) {
4622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4623 }
4624 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4625 {
4626 PyThreadState* __tstate = wxPyBeginAllowThreads();
4627 (arg1)->SetCellAttr(arg2);
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4641 wxWindow *arg2 = (wxWindow *) 0 ;
4642 int arg3 ;
4643 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4644 void *argp1 = 0 ;
4645 int res1 = 0 ;
4646 void *argp2 = 0 ;
4647 int res2 = 0 ;
4648 int val3 ;
4649 int ecode3 = 0 ;
4650 void *argp4 = 0 ;
4651 int res4 = 0 ;
4652 PyObject * obj0 = 0 ;
4653 PyObject * obj1 = 0 ;
4654 PyObject * obj2 = 0 ;
4655 PyObject * obj3 = 0 ;
4656 char * kwnames[] = {
4657 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4658 };
4659
4660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4664 }
4665 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4667 if (!SWIG_IsOK(res2)) {
4668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4669 }
4670 arg2 = reinterpret_cast< wxWindow * >(argp2);
4671 ecode3 = SWIG_AsVal_int(obj2, &val3);
4672 if (!SWIG_IsOK(ecode3)) {
4673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4674 }
4675 arg3 = static_cast< int >(val3);
4676 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4677 if (!SWIG_IsOK(res4)) {
4678 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4679 }
4680 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 (arg1)->Create(arg2,arg3,arg4);
4684 wxPyEndAllowThreads(__tstate);
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 resultobj = SWIG_Py_Void();
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj = 0;
4696 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4697 int arg2 ;
4698 int arg3 ;
4699 wxGrid *arg4 = (wxGrid *) 0 ;
4700 void *argp1 = 0 ;
4701 int res1 = 0 ;
4702 int val2 ;
4703 int ecode2 = 0 ;
4704 int val3 ;
4705 int ecode3 = 0 ;
4706 void *argp4 = 0 ;
4707 int res4 = 0 ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 PyObject * obj2 = 0 ;
4711 PyObject * obj3 = 0 ;
4712 char * kwnames[] = {
4713 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4714 };
4715
4716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4718 if (!SWIG_IsOK(res1)) {
4719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4720 }
4721 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4722 ecode2 = SWIG_AsVal_int(obj1, &val2);
4723 if (!SWIG_IsOK(ecode2)) {
4724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4725 }
4726 arg2 = static_cast< int >(val2);
4727 ecode3 = SWIG_AsVal_int(obj2, &val3);
4728 if (!SWIG_IsOK(ecode3)) {
4729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4730 }
4731 arg3 = static_cast< int >(val3);
4732 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4733 if (!SWIG_IsOK(res4)) {
4734 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4735 }
4736 arg4 = reinterpret_cast< wxGrid * >(argp4);
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 (arg1)->BeginEdit(arg2,arg3,arg4);
4740 wxPyEndAllowThreads(__tstate);
4741 if (PyErr_Occurred()) SWIG_fail;
4742 }
4743 resultobj = SWIG_Py_Void();
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4751 PyObject *resultobj = 0;
4752 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4753 int arg2 ;
4754 int arg3 ;
4755 wxGrid *arg4 = (wxGrid *) 0 ;
4756 bool result;
4757 void *argp1 = 0 ;
4758 int res1 = 0 ;
4759 int val2 ;
4760 int ecode2 = 0 ;
4761 int val3 ;
4762 int ecode3 = 0 ;
4763 void *argp4 = 0 ;
4764 int res4 = 0 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 PyObject * obj2 = 0 ;
4768 PyObject * obj3 = 0 ;
4769 char * kwnames[] = {
4770 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4771 };
4772
4773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4775 if (!SWIG_IsOK(res1)) {
4776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4777 }
4778 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4779 ecode2 = SWIG_AsVal_int(obj1, &val2);
4780 if (!SWIG_IsOK(ecode2)) {
4781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4782 }
4783 arg2 = static_cast< int >(val2);
4784 ecode3 = SWIG_AsVal_int(obj2, &val3);
4785 if (!SWIG_IsOK(ecode3)) {
4786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4787 }
4788 arg3 = static_cast< int >(val3);
4789 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4790 if (!SWIG_IsOK(res4)) {
4791 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4792 }
4793 arg4 = reinterpret_cast< wxGrid * >(argp4);
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 {
4801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4802 }
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4810 PyObject *resultobj = 0;
4811 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4812 void *argp1 = 0 ;
4813 int res1 = 0 ;
4814 PyObject *swig_obj[1] ;
4815
4816 if (!args) SWIG_fail;
4817 swig_obj[0] = args;
4818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4819 if (!SWIG_IsOK(res1)) {
4820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4821 }
4822 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->Reset();
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4837 PyObject *resultobj = 0;
4838 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4839 wxGridCellEditor *result = 0 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 PyObject *swig_obj[1] ;
4843
4844 if (!args) SWIG_fail;
4845 swig_obj[0] = args;
4846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4847 if (!SWIG_IsOK(res1)) {
4848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4849 }
4850 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4851 {
4852 PyThreadState* __tstate = wxPyBeginAllowThreads();
4853 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 {
4858 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4859 }
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj = 0;
4868 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4869 wxRect *arg2 = 0 ;
4870 void *argp1 = 0 ;
4871 int res1 = 0 ;
4872 wxRect temp2 ;
4873 PyObject * obj0 = 0 ;
4874 PyObject * obj1 = 0 ;
4875 char * kwnames[] = {
4876 (char *) "self",(char *) "rect", NULL
4877 };
4878
4879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4881 if (!SWIG_IsOK(res1)) {
4882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4883 }
4884 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4885 {
4886 arg2 = &temp2;
4887 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4888 }
4889 {
4890 PyThreadState* __tstate = wxPyBeginAllowThreads();
4891 (arg1)->SetSize((wxRect const &)*arg2);
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_Py_Void();
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj = 0;
4904 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4905 bool arg2 ;
4906 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 bool val2 ;
4910 int ecode2 = 0 ;
4911 void *argp3 = 0 ;
4912 int res3 = 0 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915 PyObject * obj2 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "show",(char *) "attr", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4922 if (!SWIG_IsOK(res1)) {
4923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4924 }
4925 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4927 if (!SWIG_IsOK(ecode2)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4929 }
4930 arg2 = static_cast< bool >(val2);
4931 if (obj2) {
4932 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4933 if (!SWIG_IsOK(res3)) {
4934 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4935 }
4936 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4937 }
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 (arg1)->Show(arg2,arg3);
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 resultobj = SWIG_Py_Void();
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4952 PyObject *resultobj = 0;
4953 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4954 wxRect *arg2 = 0 ;
4955 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4956 void *argp1 = 0 ;
4957 int res1 = 0 ;
4958 wxRect temp2 ;
4959 void *argp3 = 0 ;
4960 int res3 = 0 ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4972 }
4973 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4974 {
4975 arg2 = &temp2;
4976 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4977 }
4978 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4979 if (!SWIG_IsOK(res3)) {
4980 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4981 }
4982 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 resultobj = SWIG_Py_Void();
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj = 0;
4998 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4999 wxKeyEvent *arg2 = 0 ;
5000 bool result;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 void *argp2 = 0 ;
5004 int res2 = 0 ;
5005 PyObject * obj0 = 0 ;
5006 PyObject * obj1 = 0 ;
5007 char * kwnames[] = {
5008 (char *) "self",(char *) "event", NULL
5009 };
5010
5011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5013 if (!SWIG_IsOK(res1)) {
5014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5015 }
5016 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5017 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5018 if (!SWIG_IsOK(res2)) {
5019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5020 }
5021 if (!argp2) {
5022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5023 }
5024 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5028 wxPyEndAllowThreads(__tstate);
5029 if (PyErr_Occurred()) SWIG_fail;
5030 }
5031 {
5032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5033 }
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5041 PyObject *resultobj = 0;
5042 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5043 wxKeyEvent *arg2 = 0 ;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 void *argp2 = 0 ;
5047 int res2 = 0 ;
5048 PyObject * obj0 = 0 ;
5049 PyObject * obj1 = 0 ;
5050 char * kwnames[] = {
5051 (char *) "self",(char *) "event", NULL
5052 };
5053
5054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5058 }
5059 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5061 if (!SWIG_IsOK(res2)) {
5062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5063 }
5064 if (!argp2) {
5065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5066 }
5067 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->StartingKey(*arg2);
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_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5093 }
5094 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 (arg1)->StartingClick();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 resultobj = SWIG_Py_Void();
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5109 PyObject *resultobj = 0;
5110 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5111 wxKeyEvent *arg2 = 0 ;
5112 void *argp1 = 0 ;
5113 int res1 = 0 ;
5114 void *argp2 = 0 ;
5115 int res2 = 0 ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 char * kwnames[] = {
5119 (char *) "self",(char *) "event", NULL
5120 };
5121
5122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5124 if (!SWIG_IsOK(res1)) {
5125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5126 }
5127 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5129 if (!SWIG_IsOK(res2)) {
5130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5131 }
5132 if (!argp2) {
5133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5134 }
5135 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5136 {
5137 PyThreadState* __tstate = wxPyBeginAllowThreads();
5138 (arg1)->HandleReturn(*arg2);
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 resultobj = SWIG_Py_Void();
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5150 PyObject *resultobj = 0;
5151 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5161 }
5162 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5163 {
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 (arg1)->Destroy();
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_Py_Void();
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *obj;
5178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5179 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5180 return SWIG_Py_Void();
5181 }
5182
5183 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5184 PyObject *resultobj = 0;
5185 wxPyGridCellEditor *result = 0 ;
5186
5187 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5188 {
5189 PyThreadState* __tstate = wxPyBeginAllowThreads();
5190 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5191 wxPyEndAllowThreads(__tstate);
5192 if (PyErr_Occurred()) SWIG_fail;
5193 }
5194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj = 0;
5203 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5204 PyObject *arg2 = (PyObject *) 0 ;
5205 PyObject *arg3 = (PyObject *) 0 ;
5206 void *argp1 = 0 ;
5207 int res1 = 0 ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 PyObject * obj2 = 0 ;
5211 char * kwnames[] = {
5212 (char *) "self",(char *) "self",(char *) "_class", NULL
5213 };
5214
5215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5217 if (!SWIG_IsOK(res1)) {
5218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5219 }
5220 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5221 arg2 = obj1;
5222 arg3 = obj2;
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 (arg1)->_setCallbackInfo(arg2,arg3);
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 resultobj = SWIG_Py_Void();
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5239 wxString *arg2 = 0 ;
5240 void *argp1 = 0 ;
5241 int res1 = 0 ;
5242 bool temp2 = false ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char * kwnames[] = {
5246 (char *) "self",(char *) "params", NULL
5247 };
5248
5249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5253 }
5254 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5255 {
5256 arg2 = wxString_in_helper(obj1);
5257 if (arg2 == NULL) SWIG_fail;
5258 temp2 = true;
5259 }
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 (arg1)->SetParameters((wxString const &)*arg2);
5263 wxPyEndAllowThreads(__tstate);
5264 if (PyErr_Occurred()) SWIG_fail;
5265 }
5266 resultobj = SWIG_Py_Void();
5267 {
5268 if (temp2)
5269 delete arg2;
5270 }
5271 return resultobj;
5272 fail:
5273 {
5274 if (temp2)
5275 delete arg2;
5276 }
5277 return NULL;
5278 }
5279
5280
5281 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 PyObject *obj;
5283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5284 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5285 return SWIG_Py_Void();
5286 }
5287
5288 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5289 return SWIG_Python_InitShadowInstance(args);
5290 }
5291
5292 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 PyObject *resultobj = 0;
5294 wxGridCellTextEditor *result = 0 ;
5295
5296 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5297 {
5298 PyThreadState* __tstate = wxPyBeginAllowThreads();
5299 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5311 PyObject *resultobj = 0;
5312 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5313 wxString result;
5314 void *argp1 = 0 ;
5315 int res1 = 0 ;
5316 PyObject *swig_obj[1] ;
5317
5318 if (!args) SWIG_fail;
5319 swig_obj[0] = args;
5320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5321 if (!SWIG_IsOK(res1)) {
5322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5323 }
5324 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5325 {
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 result = (arg1)->GetValue();
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 #if wxUSE_UNICODE
5333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5334 #else
5335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5336 #endif
5337 }
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *obj;
5346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5347 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5348 return SWIG_Py_Void();
5349 }
5350
5351 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5352 return SWIG_Python_InitShadowInstance(args);
5353 }
5354
5355 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5356 PyObject *resultobj = 0;
5357 int arg1 = (int) -1 ;
5358 int arg2 = (int) -1 ;
5359 wxGridCellNumberEditor *result = 0 ;
5360 int val1 ;
5361 int ecode1 = 0 ;
5362 int val2 ;
5363 int ecode2 = 0 ;
5364 PyObject * obj0 = 0 ;
5365 PyObject * obj1 = 0 ;
5366 char * kwnames[] = {
5367 (char *) "min",(char *) "max", NULL
5368 };
5369
5370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5371 if (obj0) {
5372 ecode1 = SWIG_AsVal_int(obj0, &val1);
5373 if (!SWIG_IsOK(ecode1)) {
5374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5375 }
5376 arg1 = static_cast< int >(val1);
5377 }
5378 if (obj1) {
5379 ecode2 = SWIG_AsVal_int(obj1, &val2);
5380 if (!SWIG_IsOK(ecode2)) {
5381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5382 }
5383 arg2 = static_cast< int >(val2);
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5399 PyObject *obj;
5400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5401 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5402 return SWIG_Py_Void();
5403 }
5404
5405 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5406 return SWIG_Python_InitShadowInstance(args);
5407 }
5408
5409 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 int arg1 = (int) -1 ;
5412 int arg2 = (int) -1 ;
5413 wxGridCellFloatEditor *result = 0 ;
5414 int val1 ;
5415 int ecode1 = 0 ;
5416 int val2 ;
5417 int ecode2 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "width",(char *) "precision", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5425 if (obj0) {
5426 ecode1 = SWIG_AsVal_int(obj0, &val1);
5427 if (!SWIG_IsOK(ecode1)) {
5428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5429 }
5430 arg1 = static_cast< int >(val1);
5431 }
5432 if (obj1) {
5433 ecode2 = SWIG_AsVal_int(obj1, &val2);
5434 if (!SWIG_IsOK(ecode2)) {
5435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5436 }
5437 arg2 = static_cast< int >(val2);
5438 }
5439 {
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5442 wxPyEndAllowThreads(__tstate);
5443 if (PyErr_Occurred()) SWIG_fail;
5444 }
5445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *obj;
5454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5455 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5456 return SWIG_Py_Void();
5457 }
5458
5459 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5460 return SWIG_Python_InitShadowInstance(args);
5461 }
5462
5463 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5464 PyObject *resultobj = 0;
5465 wxGridCellBoolEditor *result = 0 ;
5466
5467 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5484 wxString result;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 PyObject *swig_obj[1] ;
5488
5489 if (!args) SWIG_fail;
5490 swig_obj[0] = args;
5491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5492 if (!SWIG_IsOK(res1)) {
5493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5494 }
5495 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5496 {
5497 PyThreadState* __tstate = wxPyBeginAllowThreads();
5498 result = (arg1)->GetValue();
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 {
5503 #if wxUSE_UNICODE
5504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5505 #else
5506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5507 #endif
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5516 PyObject *obj;
5517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5518 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5519 return SWIG_Py_Void();
5520 }
5521
5522 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 return SWIG_Python_InitShadowInstance(args);
5524 }
5525
5526 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5527 PyObject *resultobj = 0;
5528 int arg1 = (int) 0 ;
5529 wxString *arg2 = (wxString *) NULL ;
5530 bool arg3 = (bool) false ;
5531 wxGridCellChoiceEditor *result = 0 ;
5532 bool val3 ;
5533 int ecode3 = 0 ;
5534 PyObject * obj0 = 0 ;
5535 PyObject * obj1 = 0 ;
5536 char * kwnames[] = {
5537 (char *) "choices",(char *) "allowOthers", NULL
5538 };
5539
5540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5541 if (obj0) {
5542 {
5543 arg1 = PyList_Size(obj0);
5544 arg2 = wxString_LIST_helper(obj0);
5545 if (arg2 == NULL) SWIG_fail;
5546 }
5547 }
5548 if (obj1) {
5549 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5550 if (!SWIG_IsOK(ecode3)) {
5551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5552 }
5553 arg3 = static_cast< bool >(val3);
5554 }
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5562 {
5563 if (arg2) delete [] arg2;
5564 }
5565 return resultobj;
5566 fail:
5567 {
5568 if (arg2) delete [] arg2;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5577 wxString result;
5578 void *argp1 = 0 ;
5579 int res1 = 0 ;
5580 PyObject *swig_obj[1] ;
5581
5582 if (!args) SWIG_fail;
5583 swig_obj[0] = args;
5584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5585 if (!SWIG_IsOK(res1)) {
5586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5587 }
5588 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5589 {
5590 PyThreadState* __tstate = wxPyBeginAllowThreads();
5591 result = (arg1)->GetValue();
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 {
5596 #if wxUSE_UNICODE
5597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5598 #else
5599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5600 #endif
5601 }
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5609 PyObject *obj;
5610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5611 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5612 return SWIG_Py_Void();
5613 }
5614
5615 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 return SWIG_Python_InitShadowInstance(args);
5617 }
5618
5619 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj = 0;
5621 wxString const &arg1_defvalue = wxPyEmptyString ;
5622 wxString *arg1 = (wxString *) &arg1_defvalue ;
5623 wxGridCellEnumEditor *result = 0 ;
5624 bool temp1 = false ;
5625 PyObject * obj0 = 0 ;
5626 char * kwnames[] = {
5627 (char *) "choices", NULL
5628 };
5629
5630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5631 if (obj0) {
5632 {
5633 arg1 = wxString_in_helper(obj0);
5634 if (arg1 == NULL) SWIG_fail;
5635 temp1 = true;
5636 }
5637 }
5638 {
5639 PyThreadState* __tstate = wxPyBeginAllowThreads();
5640 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5641 wxPyEndAllowThreads(__tstate);
5642 if (PyErr_Occurred()) SWIG_fail;
5643 }
5644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5645 {
5646 if (temp1)
5647 delete arg1;
5648 }
5649 return resultobj;
5650 fail:
5651 {
5652 if (temp1)
5653 delete arg1;
5654 }
5655 return NULL;
5656 }
5657
5658
5659 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5660 PyObject *obj;
5661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5662 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5663 return SWIG_Py_Void();
5664 }
5665
5666 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5667 return SWIG_Python_InitShadowInstance(args);
5668 }
5669
5670 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5671 PyObject *resultobj = 0;
5672 wxGridCellAutoWrapStringEditor *result = 0 ;
5673
5674 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5675 {
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *obj;
5690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5691 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5692 return SWIG_Py_Void();
5693 }
5694
5695 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 return SWIG_Python_InitShadowInstance(args);
5697 }
5698
5699 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5700 PyObject *resultobj = 0;
5701 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5702 PyObject *arg2 = (PyObject *) 0 ;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 char * kwnames[] = {
5708 (char *) "self",(char *) "_self", NULL
5709 };
5710
5711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5715 }
5716 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5717 arg2 = obj1;
5718 {
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 wxGridCellAttr__setOORInfo(arg1,arg2);
5721 wxPyEndAllowThreads(__tstate);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 resultobj = SWIG_Py_Void();
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5734 wxGridCellAttr *result = 0 ;
5735 void *argp1 = 0 ;
5736 int res1 = 0 ;
5737 PyObject * obj0 = 0 ;
5738 char * kwnames[] = {
5739 (char *) "attrDefault", NULL
5740 };
5741
5742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5743 if (obj0) {
5744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5745 if (!SWIG_IsOK(res1)) {
5746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5747 }
5748 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5749 }
5750 {
5751 PyThreadState* __tstate = wxPyBeginAllowThreads();
5752 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5753 wxPyEndAllowThreads(__tstate);
5754 if (PyErr_Occurred()) SWIG_fail;
5755 }
5756 {
5757 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5758 }
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5766 PyObject *resultobj = 0;
5767 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5768 void *argp1 = 0 ;
5769 int res1 = 0 ;
5770 PyObject *swig_obj[1] ;
5771
5772 if (!args) SWIG_fail;
5773 swig_obj[0] = args;
5774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5775 if (!SWIG_IsOK(res1)) {
5776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5777 }
5778 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5779 {
5780 PyThreadState* __tstate = wxPyBeginAllowThreads();
5781 delete_wxGridCellAttr(arg1);
5782
5783 wxPyEndAllowThreads(__tstate);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 resultobj = SWIG_Py_Void();
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 PyObject *resultobj = 0;
5795 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5796 wxGridCellAttr *result = 0 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 PyObject *swig_obj[1] ;
5800
5801 if (!args) SWIG_fail;
5802 swig_obj[0] = args;
5803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5804 if (!SWIG_IsOK(res1)) {
5805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5806 }
5807 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5808 {
5809 PyThreadState* __tstate = wxPyBeginAllowThreads();
5810 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 {
5815 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5816 }
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj = 0;
5825 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5826 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 void *argp2 = 0 ;
5830 int res2 = 0 ;
5831 PyObject * obj0 = 0 ;
5832 PyObject * obj1 = 0 ;
5833 char * kwnames[] = {
5834 (char *) "self",(char *) "mergefrom", NULL
5835 };
5836
5837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5839 if (!SWIG_IsOK(res1)) {
5840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5841 }
5842 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5843 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5844 if (!SWIG_IsOK(res2)) {
5845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5846 }
5847 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5848 {
5849 PyThreadState* __tstate = wxPyBeginAllowThreads();
5850 (arg1)->MergeWith(arg2);
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 resultobj = SWIG_Py_Void();
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5862 PyObject *resultobj = 0;
5863 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5864 void *argp1 = 0 ;
5865 int res1 = 0 ;
5866 PyObject *swig_obj[1] ;
5867
5868 if (!args) SWIG_fail;
5869 swig_obj[0] = args;
5870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5871 if (!SWIG_IsOK(res1)) {
5872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5873 }
5874 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5875 {
5876 PyThreadState* __tstate = wxPyBeginAllowThreads();
5877 (arg1)->IncRef();
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 resultobj = SWIG_Py_Void();
5882 return resultobj;
5883 fail:
5884 return NULL;
5885 }
5886
5887
5888 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889 PyObject *resultobj = 0;
5890 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5891 void *argp1 = 0 ;
5892 int res1 = 0 ;
5893 PyObject *swig_obj[1] ;
5894
5895 if (!args) SWIG_fail;
5896 swig_obj[0] = args;
5897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5898 if (!SWIG_IsOK(res1)) {
5899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5900 }
5901 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 (arg1)->DecRef();
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 resultobj = SWIG_Py_Void();
5909 return resultobj;
5910 fail:
5911 return NULL;
5912 }
5913
5914
5915 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj = 0;
5917 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5918 wxColour *arg2 = 0 ;
5919 void *argp1 = 0 ;
5920 int res1 = 0 ;
5921 wxColour temp2 ;
5922 PyObject * obj0 = 0 ;
5923 PyObject * obj1 = 0 ;
5924 char * kwnames[] = {
5925 (char *) "self",(char *) "colText", NULL
5926 };
5927
5928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5930 if (!SWIG_IsOK(res1)) {
5931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5932 }
5933 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5934 {
5935 arg2 = &temp2;
5936 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5937 }
5938 {
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 (arg1)->SetTextColour((wxColour const &)*arg2);
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 resultobj = SWIG_Py_Void();
5945 return resultobj;
5946 fail:
5947 return NULL;
5948 }
5949
5950
5951 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5952 PyObject *resultobj = 0;
5953 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5954 wxColour *arg2 = 0 ;
5955 void *argp1 = 0 ;
5956 int res1 = 0 ;
5957 wxColour temp2 ;
5958 PyObject * obj0 = 0 ;
5959 PyObject * obj1 = 0 ;
5960 char * kwnames[] = {
5961 (char *) "self",(char *) "colBack", NULL
5962 };
5963
5964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5966 if (!SWIG_IsOK(res1)) {
5967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5968 }
5969 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5970 {
5971 arg2 = &temp2;
5972 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5973 }
5974 {
5975 PyThreadState* __tstate = wxPyBeginAllowThreads();
5976 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 resultobj = SWIG_Py_Void();
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj = 0;
5989 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5990 wxFont *arg2 = 0 ;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 void *argp2 = 0 ;
5994 int res2 = 0 ;
5995 PyObject * obj0 = 0 ;
5996 PyObject * obj1 = 0 ;
5997 char * kwnames[] = {
5998 (char *) "self",(char *) "font", NULL
5999 };
6000
6001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6003 if (!SWIG_IsOK(res1)) {
6004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6005 }
6006 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6008 if (!SWIG_IsOK(res2)) {
6009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6010 }
6011 if (!argp2) {
6012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6013 }
6014 arg2 = reinterpret_cast< wxFont * >(argp2);
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 (arg1)->SetFont((wxFont const &)*arg2);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 resultobj = SWIG_Py_Void();
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj = 0;
6030 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6031 int arg2 ;
6032 int arg3 ;
6033 void *argp1 = 0 ;
6034 int res1 = 0 ;
6035 int val2 ;
6036 int ecode2 = 0 ;
6037 int val3 ;
6038 int ecode3 = 0 ;
6039 PyObject * obj0 = 0 ;
6040 PyObject * obj1 = 0 ;
6041 PyObject * obj2 = 0 ;
6042 char * kwnames[] = {
6043 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6044 };
6045
6046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6048 if (!SWIG_IsOK(res1)) {
6049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6050 }
6051 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6052 ecode2 = SWIG_AsVal_int(obj1, &val2);
6053 if (!SWIG_IsOK(ecode2)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6055 }
6056 arg2 = static_cast< int >(val2);
6057 ecode3 = SWIG_AsVal_int(obj2, &val3);
6058 if (!SWIG_IsOK(ecode3)) {
6059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6060 }
6061 arg3 = static_cast< int >(val3);
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 (arg1)->SetAlignment(arg2,arg3);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = SWIG_Py_Void();
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = 0;
6077 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6078 int arg2 ;
6079 int arg3 ;
6080 void *argp1 = 0 ;
6081 int res1 = 0 ;
6082 int val2 ;
6083 int ecode2 = 0 ;
6084 int val3 ;
6085 int ecode3 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 char * kwnames[] = {
6090 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6091 };
6092
6093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6095 if (!SWIG_IsOK(res1)) {
6096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6097 }
6098 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6099 ecode2 = SWIG_AsVal_int(obj1, &val2);
6100 if (!SWIG_IsOK(ecode2)) {
6101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6102 }
6103 arg2 = static_cast< int >(val2);
6104 ecode3 = SWIG_AsVal_int(obj2, &val3);
6105 if (!SWIG_IsOK(ecode3)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6107 }
6108 arg3 = static_cast< int >(val3);
6109 {
6110 PyThreadState* __tstate = wxPyBeginAllowThreads();
6111 (arg1)->SetSize(arg2,arg3);
6112 wxPyEndAllowThreads(__tstate);
6113 if (PyErr_Occurred()) SWIG_fail;
6114 }
6115 resultobj = SWIG_Py_Void();
6116 return resultobj;
6117 fail:
6118 return NULL;
6119 }
6120
6121
6122 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6123 PyObject *resultobj = 0;
6124 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6125 bool arg2 = (bool) true ;
6126 void *argp1 = 0 ;
6127 int res1 = 0 ;
6128 bool val2 ;
6129 int ecode2 = 0 ;
6130 PyObject * obj0 = 0 ;
6131 PyObject * obj1 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "self",(char *) "allow", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6138 if (!SWIG_IsOK(res1)) {
6139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6140 }
6141 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6142 if (obj1) {
6143 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6144 if (!SWIG_IsOK(ecode2)) {
6145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6146 }
6147 arg2 = static_cast< bool >(val2);
6148 }
6149 {
6150 PyThreadState* __tstate = wxPyBeginAllowThreads();
6151 (arg1)->SetOverflow(arg2);
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 resultobj = SWIG_Py_Void();
6156 return resultobj;
6157 fail:
6158 return NULL;
6159 }
6160
6161
6162 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6163 PyObject *resultobj = 0;
6164 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6165 bool arg2 = (bool) true ;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 bool val2 ;
6169 int ecode2 = 0 ;
6170 PyObject * obj0 = 0 ;
6171 PyObject * obj1 = 0 ;
6172 char * kwnames[] = {
6173 (char *) "self",(char *) "isReadOnly", NULL
6174 };
6175
6176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6178 if (!SWIG_IsOK(res1)) {
6179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6180 }
6181 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6182 if (obj1) {
6183 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6184 if (!SWIG_IsOK(ecode2)) {
6185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6186 }
6187 arg2 = static_cast< bool >(val2);
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 (arg1)->SetReadOnly(arg2);
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 resultobj = SWIG_Py_Void();
6196 return resultobj;
6197 fail:
6198 return NULL;
6199 }
6200
6201
6202 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj = 0;
6204 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6205 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6206 void *argp1 = 0 ;
6207 int res1 = 0 ;
6208 void *argp2 = 0 ;
6209 int res2 = 0 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "self",(char *) "renderer", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6220 }
6221 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6223 if (!SWIG_IsOK(res2)) {
6224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6225 }
6226 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6227 {
6228 PyThreadState* __tstate = wxPyBeginAllowThreads();
6229 (arg1)->SetRenderer(arg2);
6230 wxPyEndAllowThreads(__tstate);
6231 if (PyErr_Occurred()) SWIG_fail;
6232 }
6233 resultobj = SWIG_Py_Void();
6234 return resultobj;
6235 fail:
6236 return NULL;
6237 }
6238
6239
6240 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6241 PyObject *resultobj = 0;
6242 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6243 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6244 void *argp1 = 0 ;
6245 int res1 = 0 ;
6246 void *argp2 = 0 ;
6247 int res2 = 0 ;
6248 PyObject * obj0 = 0 ;
6249 PyObject * obj1 = 0 ;
6250 char * kwnames[] = {
6251 (char *) "self",(char *) "editor", NULL
6252 };
6253
6254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6256 if (!SWIG_IsOK(res1)) {
6257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6258 }
6259 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6261 if (!SWIG_IsOK(res2)) {
6262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6263 }
6264 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 (arg1)->SetEditor(arg2);
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj = 0;
6280 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6281 wxGridCellAttr::wxAttrKind arg2 ;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 int val2 ;
6285 int ecode2 = 0 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char * kwnames[] = {
6289 (char *) "self",(char *) "kind", NULL
6290 };
6291
6292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6294 if (!SWIG_IsOK(res1)) {
6295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6296 }
6297 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6298 ecode2 = SWIG_AsVal_int(obj1, &val2);
6299 if (!SWIG_IsOK(ecode2)) {
6300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6301 }
6302 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 (arg1)->SetKind(arg2);
6306 wxPyEndAllowThreads(__tstate);
6307 if (PyErr_Occurred()) SWIG_fail;
6308 }
6309 resultobj = SWIG_Py_Void();
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6317 PyObject *resultobj = 0;
6318 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6319 bool result;
6320 void *argp1 = 0 ;
6321 int res1 = 0 ;
6322 PyObject *swig_obj[1] ;
6323
6324 if (!args) SWIG_fail;
6325 swig_obj[0] = args;
6326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6327 if (!SWIG_IsOK(res1)) {
6328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6329 }
6330 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 {
6338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6339 }
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6349 bool result;
6350 void *argp1 = 0 ;
6351 int res1 = 0 ;
6352 PyObject *swig_obj[1] ;
6353
6354 if (!args) SWIG_fail;
6355 swig_obj[0] = args;
6356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6357 if (!SWIG_IsOK(res1)) {
6358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6359 }
6360 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6361 {
6362 PyThreadState* __tstate = wxPyBeginAllowThreads();
6363 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 {
6368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6377 PyObject *resultobj = 0;
6378 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6379 bool result;
6380 void *argp1 = 0 ;
6381 int res1 = 0 ;
6382 PyObject *swig_obj[1] ;
6383
6384 if (!args) SWIG_fail;
6385 swig_obj[0] = args;
6386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6389 }
6390 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6391 {
6392 PyThreadState* __tstate = wxPyBeginAllowThreads();
6393 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6394 wxPyEndAllowThreads(__tstate);
6395 if (PyErr_Occurred()) SWIG_fail;
6396 }
6397 {
6398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6399 }
6400 return resultobj;
6401 fail:
6402 return NULL;
6403 }
6404
6405
6406 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6407 PyObject *resultobj = 0;
6408 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6409 bool result;
6410 void *argp1 = 0 ;
6411 int res1 = 0 ;
6412 PyObject *swig_obj[1] ;
6413
6414 if (!args) SWIG_fail;
6415 swig_obj[0] = args;
6416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6417 if (!SWIG_IsOK(res1)) {
6418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6419 }
6420 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6421 {
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 {
6428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6429 }
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6437 PyObject *resultobj = 0;
6438 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6439 bool result;
6440 void *argp1 = 0 ;
6441 int res1 = 0 ;
6442 PyObject *swig_obj[1] ;
6443
6444 if (!args) SWIG_fail;
6445 swig_obj[0] = args;
6446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6447 if (!SWIG_IsOK(res1)) {
6448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6449 }
6450 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 {
6458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6459 }
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6467 PyObject *resultobj = 0;
6468 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6469 bool result;
6470 void *argp1 = 0 ;
6471 int res1 = 0 ;
6472 PyObject *swig_obj[1] ;
6473
6474 if (!args) SWIG_fail;
6475 swig_obj[0] = args;
6476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6477 if (!SWIG_IsOK(res1)) {
6478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6479 }
6480 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6481 {
6482 PyThreadState* __tstate = wxPyBeginAllowThreads();
6483 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 {
6488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6489 }
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6497 PyObject *resultobj = 0;
6498 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6499 bool result;
6500 void *argp1 = 0 ;
6501 int res1 = 0 ;
6502 PyObject *swig_obj[1] ;
6503
6504 if (!args) SWIG_fail;
6505 swig_obj[0] = args;
6506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6509 }
6510 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6511 {
6512 PyThreadState* __tstate = wxPyBeginAllowThreads();
6513 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 {
6518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6519 }
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6529 bool result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 {
6548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6549 }
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6559 wxColour result;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 PyObject *swig_obj[1] ;
6563
6564 if (!args) SWIG_fail;
6565 swig_obj[0] = args;
6566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6567 if (!SWIG_IsOK(res1)) {
6568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6569 }
6570 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6585 PyObject *resultobj = 0;
6586 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6587 wxColour result;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 PyObject *swig_obj[1] ;
6591
6592 if (!args) SWIG_fail;
6593 swig_obj[0] = args;
6594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6595 if (!SWIG_IsOK(res1)) {
6596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6597 }
6598 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6602 wxPyEndAllowThreads(__tstate);
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6613 PyObject *resultobj = 0;
6614 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6615 wxFont result;
6616 void *argp1 = 0 ;
6617 int res1 = 0 ;
6618 PyObject *swig_obj[1] ;
6619
6620 if (!args) SWIG_fail;
6621 swig_obj[0] = args;
6622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6623 if (!SWIG_IsOK(res1)) {
6624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6625 }
6626 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6627 {
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 result = ((wxGridCellAttr const *)arg1)->GetFont();
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641 PyObject *resultobj = 0;
6642 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6643 int *arg2 = (int *) 0 ;
6644 int *arg3 = (int *) 0 ;
6645 void *argp1 = 0 ;
6646 int res1 = 0 ;
6647 int temp2 ;
6648 int res2 = SWIG_TMPOBJ ;
6649 int temp3 ;
6650 int res3 = SWIG_TMPOBJ ;
6651 PyObject *swig_obj[1] ;
6652
6653 arg2 = &temp2;
6654 arg3 = &temp3;
6655 if (!args) SWIG_fail;
6656 swig_obj[0] = args;
6657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6658 if (!SWIG_IsOK(res1)) {
6659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6660 }
6661 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6665 wxPyEndAllowThreads(__tstate);
6666 if (PyErr_Occurred()) SWIG_fail;
6667 }
6668 resultobj = SWIG_Py_Void();
6669 if (SWIG_IsTmpObj(res2)) {
6670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6671 } else {
6672 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6674 }
6675 if (SWIG_IsTmpObj(res3)) {
6676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6677 } else {
6678 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6680 }
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6690 int *arg2 = (int *) 0 ;
6691 int *arg3 = (int *) 0 ;
6692 void *argp1 = 0 ;
6693 int res1 = 0 ;
6694 int temp2 ;
6695 int res2 = SWIG_TMPOBJ ;
6696 int temp3 ;
6697 int res3 = SWIG_TMPOBJ ;
6698 PyObject *swig_obj[1] ;
6699
6700 arg2 = &temp2;
6701 arg3 = &temp3;
6702 if (!args) SWIG_fail;
6703 swig_obj[0] = args;
6704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6705 if (!SWIG_IsOK(res1)) {
6706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6707 }
6708 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_Py_Void();
6716 if (SWIG_IsTmpObj(res2)) {
6717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6718 } else {
6719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6721 }
6722 if (SWIG_IsTmpObj(res3)) {
6723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6724 } else {
6725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6727 }
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6735 PyObject *resultobj = 0;
6736 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6737 bool result;
6738 void *argp1 = 0 ;
6739 int res1 = 0 ;
6740 PyObject *swig_obj[1] ;
6741
6742 if (!args) SWIG_fail;
6743 swig_obj[0] = args;
6744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6745 if (!SWIG_IsOK(res1)) {
6746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6747 }
6748 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6749 {
6750 PyThreadState* __tstate = wxPyBeginAllowThreads();
6751 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6752 wxPyEndAllowThreads(__tstate);
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 {
6756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6757 }
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj = 0;
6766 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6767 wxGrid *arg2 = (wxGrid *) 0 ;
6768 int arg3 ;
6769 int arg4 ;
6770 wxGridCellRenderer *result = 0 ;
6771 void *argp1 = 0 ;
6772 int res1 = 0 ;
6773 void *argp2 = 0 ;
6774 int res2 = 0 ;
6775 int val3 ;
6776 int ecode3 = 0 ;
6777 int val4 ;
6778 int ecode4 = 0 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 PyObject * obj2 = 0 ;
6782 PyObject * obj3 = 0 ;
6783 char * kwnames[] = {
6784 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6785 };
6786
6787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6789 if (!SWIG_IsOK(res1)) {
6790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6791 }
6792 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6794 if (!SWIG_IsOK(res2)) {
6795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6796 }
6797 arg2 = reinterpret_cast< wxGrid * >(argp2);
6798 ecode3 = SWIG_AsVal_int(obj2, &val3);
6799 if (!SWIG_IsOK(ecode3)) {
6800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6801 }
6802 arg3 = static_cast< int >(val3);
6803 ecode4 = SWIG_AsVal_int(obj3, &val4);
6804 if (!SWIG_IsOK(ecode4)) {
6805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6806 }
6807 arg4 = static_cast< int >(val4);
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = 0;
6825 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6826 wxGrid *arg2 = (wxGrid *) 0 ;
6827 int arg3 ;
6828 int arg4 ;
6829 wxGridCellEditor *result = 0 ;
6830 void *argp1 = 0 ;
6831 int res1 = 0 ;
6832 void *argp2 = 0 ;
6833 int res2 = 0 ;
6834 int val3 ;
6835 int ecode3 = 0 ;
6836 int val4 ;
6837 int ecode4 = 0 ;
6838 PyObject * obj0 = 0 ;
6839 PyObject * obj1 = 0 ;
6840 PyObject * obj2 = 0 ;
6841 PyObject * obj3 = 0 ;
6842 char * kwnames[] = {
6843 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6844 };
6845
6846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6853 if (!SWIG_IsOK(res2)) {
6854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6855 }
6856 arg2 = reinterpret_cast< wxGrid * >(argp2);
6857 ecode3 = SWIG_AsVal_int(obj2, &val3);
6858 if (!SWIG_IsOK(ecode3)) {
6859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6860 }
6861 arg3 = static_cast< int >(val3);
6862 ecode4 = SWIG_AsVal_int(obj3, &val4);
6863 if (!SWIG_IsOK(ecode4)) {
6864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6865 }
6866 arg4 = static_cast< int >(val4);
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6870 wxPyEndAllowThreads(__tstate);
6871 if (PyErr_Occurred()) SWIG_fail;
6872 }
6873 {
6874 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6875 }
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6885 bool result;
6886 void *argp1 = 0 ;
6887 int res1 = 0 ;
6888 PyObject *swig_obj[1] ;
6889
6890 if (!args) SWIG_fail;
6891 swig_obj[0] = args;
6892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6893 if (!SWIG_IsOK(res1)) {
6894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6895 }
6896 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6900 wxPyEndAllowThreads(__tstate);
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 {
6904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6905 }
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6915 wxGridCellAttr::wxAttrKind result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6925 }
6926 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6943 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 void *argp2 = 0 ;
6947 int res2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "defAttr", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6958 }
6959 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6961 if (!SWIG_IsOK(res2)) {
6962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6963 }
6964 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetDefAttr(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6979 PyObject *obj;
6980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6981 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
6982 return SWIG_Py_Void();
6983 }
6984
6985 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6986 return SWIG_Python_InitShadowInstance(args);
6987 }
6988
6989 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 wxGridCellAttrProvider *result = 0 ;
6992
6993 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
6994 {
6995 PyThreadState* __tstate = wxPyBeginAllowThreads();
6996 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
6997 wxPyEndAllowThreads(__tstate);
6998 if (PyErr_Occurred()) SWIG_fail;
6999 }
7000 {
7001 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj = 0;
7011 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7012 PyObject *arg2 = (PyObject *) 0 ;
7013 void *argp1 = 0 ;
7014 int res1 = 0 ;
7015 PyObject * obj0 = 0 ;
7016 PyObject * obj1 = 0 ;
7017 char * kwnames[] = {
7018 (char *) "self",(char *) "_self", NULL
7019 };
7020
7021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7023 if (!SWIG_IsOK(res1)) {
7024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7025 }
7026 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7027 arg2 = obj1;
7028 {
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_Py_Void();
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj = 0;
7043 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7044 int arg2 ;
7045 int arg3 ;
7046 wxGridCellAttr::wxAttrKind arg4 ;
7047 wxGridCellAttr *result = 0 ;
7048 void *argp1 = 0 ;
7049 int res1 = 0 ;
7050 int val2 ;
7051 int ecode2 = 0 ;
7052 int val3 ;
7053 int ecode3 = 0 ;
7054 int val4 ;
7055 int ecode4 = 0 ;
7056 PyObject * obj0 = 0 ;
7057 PyObject * obj1 = 0 ;
7058 PyObject * obj2 = 0 ;
7059 PyObject * obj3 = 0 ;
7060 char * kwnames[] = {
7061 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7062 };
7063
7064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7066 if (!SWIG_IsOK(res1)) {
7067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7068 }
7069 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7070 ecode2 = SWIG_AsVal_int(obj1, &val2);
7071 if (!SWIG_IsOK(ecode2)) {
7072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7073 }
7074 arg2 = static_cast< int >(val2);
7075 ecode3 = SWIG_AsVal_int(obj2, &val3);
7076 if (!SWIG_IsOK(ecode3)) {
7077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7078 }
7079 arg3 = static_cast< int >(val3);
7080 ecode4 = SWIG_AsVal_int(obj3, &val4);
7081 if (!SWIG_IsOK(ecode4)) {
7082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7083 }
7084 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7085 {
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7088 wxPyEndAllowThreads(__tstate);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 {
7092 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7093 }
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj = 0;
7102 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7103 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7104 int arg3 ;
7105 int arg4 ;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 void *argp2 = 0 ;
7109 int res2 = 0 ;
7110 int val3 ;
7111 int ecode3 = 0 ;
7112 int val4 ;
7113 int ecode4 = 0 ;
7114 PyObject * obj0 = 0 ;
7115 PyObject * obj1 = 0 ;
7116 PyObject * obj2 = 0 ;
7117 PyObject * obj3 = 0 ;
7118 char * kwnames[] = {
7119 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7120 };
7121
7122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7126 }
7127 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7129 if (!SWIG_IsOK(res2)) {
7130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7131 }
7132 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7133 ecode3 = SWIG_AsVal_int(obj2, &val3);
7134 if (!SWIG_IsOK(ecode3)) {
7135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7136 }
7137 arg3 = static_cast< int >(val3);
7138 ecode4 = SWIG_AsVal_int(obj3, &val4);
7139 if (!SWIG_IsOK(ecode4)) {
7140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7141 }
7142 arg4 = static_cast< int >(val4);
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 (arg1)->SetAttr(arg2,arg3,arg4);
7146 wxPyEndAllowThreads(__tstate);
7147 if (PyErr_Occurred()) SWIG_fail;
7148 }
7149 resultobj = SWIG_Py_Void();
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj = 0;
7158 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7159 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7160 int arg3 ;
7161 void *argp1 = 0 ;
7162 int res1 = 0 ;
7163 void *argp2 = 0 ;
7164 int res2 = 0 ;
7165 int val3 ;
7166 int ecode3 = 0 ;
7167 PyObject * obj0 = 0 ;
7168 PyObject * obj1 = 0 ;
7169 PyObject * obj2 = 0 ;
7170 char * kwnames[] = {
7171 (char *) "self",(char *) "attr",(char *) "row", NULL
7172 };
7173
7174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7176 if (!SWIG_IsOK(res1)) {
7177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7178 }
7179 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7181 if (!SWIG_IsOK(res2)) {
7182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7183 }
7184 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7185 ecode3 = SWIG_AsVal_int(obj2, &val3);
7186 if (!SWIG_IsOK(ecode3)) {
7187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7188 }
7189 arg3 = static_cast< int >(val3);
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 (arg1)->SetRowAttr(arg2,arg3);
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 resultobj = SWIG_Py_Void();
7197 return resultobj;
7198 fail:
7199 return NULL;
7200 }
7201
7202
7203 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7204 PyObject *resultobj = 0;
7205 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7206 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7207 int arg3 ;
7208 void *argp1 = 0 ;
7209 int res1 = 0 ;
7210 void *argp2 = 0 ;
7211 int res2 = 0 ;
7212 int val3 ;
7213 int ecode3 = 0 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 PyObject * obj2 = 0 ;
7217 char * kwnames[] = {
7218 (char *) "self",(char *) "attr",(char *) "col", NULL
7219 };
7220
7221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7223 if (!SWIG_IsOK(res1)) {
7224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7225 }
7226 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7228 if (!SWIG_IsOK(res2)) {
7229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7230 }
7231 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7232 ecode3 = SWIG_AsVal_int(obj2, &val3);
7233 if (!SWIG_IsOK(ecode3)) {
7234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7235 }
7236 arg3 = static_cast< int >(val3);
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 (arg1)->SetColAttr(arg2,arg3);
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 resultobj = SWIG_Py_Void();
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj = 0;
7252 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7253 size_t arg2 ;
7254 int arg3 ;
7255 void *argp1 = 0 ;
7256 int res1 = 0 ;
7257 size_t val2 ;
7258 int ecode2 = 0 ;
7259 int val3 ;
7260 int ecode3 = 0 ;
7261 PyObject * obj0 = 0 ;
7262 PyObject * obj1 = 0 ;
7263 PyObject * obj2 = 0 ;
7264 char * kwnames[] = {
7265 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7266 };
7267
7268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7270 if (!SWIG_IsOK(res1)) {
7271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7272 }
7273 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7274 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7275 if (!SWIG_IsOK(ecode2)) {
7276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7277 }
7278 arg2 = static_cast< size_t >(val2);
7279 ecode3 = SWIG_AsVal_int(obj2, &val3);
7280 if (!SWIG_IsOK(ecode3)) {
7281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7282 }
7283 arg3 = static_cast< int >(val3);
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 (arg1)->UpdateAttrRows(arg2,arg3);
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 resultobj = SWIG_Py_Void();
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj = 0;
7299 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7300 size_t arg2 ;
7301 int arg3 ;
7302 void *argp1 = 0 ;
7303 int res1 = 0 ;
7304 size_t val2 ;
7305 int ecode2 = 0 ;
7306 int val3 ;
7307 int ecode3 = 0 ;
7308 PyObject * obj0 = 0 ;
7309 PyObject * obj1 = 0 ;
7310 PyObject * obj2 = 0 ;
7311 char * kwnames[] = {
7312 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7313 };
7314
7315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) 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_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7319 }
7320 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7321 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7322 if (!SWIG_IsOK(ecode2)) {
7323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7324 }
7325 arg2 = static_cast< size_t >(val2);
7326 ecode3 = SWIG_AsVal_int(obj2, &val3);
7327 if (!SWIG_IsOK(ecode3)) {
7328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7329 }
7330 arg3 = static_cast< int >(val3);
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 (arg1)->UpdateAttrCols(arg2,arg3);
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = SWIG_Py_Void();
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7345 PyObject *obj;
7346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7347 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7348 return SWIG_Py_Void();
7349 }
7350
7351 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 return SWIG_Python_InitShadowInstance(args);
7353 }
7354
7355 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7356 PyObject *resultobj = 0;
7357 wxPyGridCellAttrProvider *result = 0 ;
7358
7359 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7363 wxPyEndAllowThreads(__tstate);
7364 if (PyErr_Occurred()) SWIG_fail;
7365 }
7366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7374 PyObject *resultobj = 0;
7375 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7376 PyObject *arg2 = (PyObject *) 0 ;
7377 PyObject *arg3 = (PyObject *) 0 ;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 PyObject * obj2 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "self",(char *) "_class", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7391 }
7392 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7393 arg2 = obj1;
7394 arg3 = obj2;
7395 {
7396 PyThreadState* __tstate = wxPyBeginAllowThreads();
7397 (arg1)->_setCallbackInfo(arg2,arg3);
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 resultobj = SWIG_Py_Void();
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj = 0;
7410 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7411 int arg2 ;
7412 int arg3 ;
7413 wxGridCellAttr::wxAttrKind arg4 ;
7414 wxGridCellAttr *result = 0 ;
7415 void *argp1 = 0 ;
7416 int res1 = 0 ;
7417 int val2 ;
7418 int ecode2 = 0 ;
7419 int val3 ;
7420 int ecode3 = 0 ;
7421 int val4 ;
7422 int ecode4 = 0 ;
7423 PyObject * obj0 = 0 ;
7424 PyObject * obj1 = 0 ;
7425 PyObject * obj2 = 0 ;
7426 PyObject * obj3 = 0 ;
7427 char * kwnames[] = {
7428 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7429 };
7430
7431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7433 if (!SWIG_IsOK(res1)) {
7434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7435 }
7436 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7437 ecode2 = SWIG_AsVal_int(obj1, &val2);
7438 if (!SWIG_IsOK(ecode2)) {
7439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7440 }
7441 arg2 = static_cast< int >(val2);
7442 ecode3 = SWIG_AsVal_int(obj2, &val3);
7443 if (!SWIG_IsOK(ecode3)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7445 }
7446 arg3 = static_cast< int >(val3);
7447 ecode4 = SWIG_AsVal_int(obj3, &val4);
7448 if (!SWIG_IsOK(ecode4)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7450 }
7451 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 {
7459 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7460 }
7461 return resultobj;
7462 fail:
7463 return NULL;
7464 }
7465
7466
7467 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7468 PyObject *resultobj = 0;
7469 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7470 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7471 int arg3 ;
7472 int arg4 ;
7473 void *argp1 = 0 ;
7474 int res1 = 0 ;
7475 void *argp2 = 0 ;
7476 int res2 = 0 ;
7477 int val3 ;
7478 int ecode3 = 0 ;
7479 int val4 ;
7480 int ecode4 = 0 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 PyObject * obj2 = 0 ;
7484 PyObject * obj3 = 0 ;
7485 char * kwnames[] = {
7486 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7487 };
7488
7489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7491 if (!SWIG_IsOK(res1)) {
7492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7493 }
7494 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7496 if (!SWIG_IsOK(res2)) {
7497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7498 }
7499 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7500 ecode3 = SWIG_AsVal_int(obj2, &val3);
7501 if (!SWIG_IsOK(ecode3)) {
7502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7503 }
7504 arg3 = static_cast< int >(val3);
7505 ecode4 = SWIG_AsVal_int(obj3, &val4);
7506 if (!SWIG_IsOK(ecode4)) {
7507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7508 }
7509 arg4 = static_cast< int >(val4);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 (arg1)->SetAttr(arg2,arg3,arg4);
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 resultobj = SWIG_Py_Void();
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj = 0;
7525 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7526 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7527 int arg3 ;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 void *argp2 = 0 ;
7531 int res2 = 0 ;
7532 int val3 ;
7533 int ecode3 = 0 ;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 PyObject * obj2 = 0 ;
7537 char * kwnames[] = {
7538 (char *) "self",(char *) "attr",(char *) "row", NULL
7539 };
7540
7541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7545 }
7546 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7548 if (!SWIG_IsOK(res2)) {
7549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7550 }
7551 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7552 ecode3 = SWIG_AsVal_int(obj2, &val3);
7553 if (!SWIG_IsOK(ecode3)) {
7554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7555 }
7556 arg3 = static_cast< int >(val3);
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 (arg1)->SetRowAttr(arg2,arg3);
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 resultobj = SWIG_Py_Void();
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj = 0;
7572 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7573 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7574 int arg3 ;
7575 void *argp1 = 0 ;
7576 int res1 = 0 ;
7577 void *argp2 = 0 ;
7578 int res2 = 0 ;
7579 int val3 ;
7580 int ecode3 = 0 ;
7581 PyObject * obj0 = 0 ;
7582 PyObject * obj1 = 0 ;
7583 PyObject * obj2 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "attr",(char *) "col", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7592 }
7593 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7595 if (!SWIG_IsOK(res2)) {
7596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7597 }
7598 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7599 ecode3 = SWIG_AsVal_int(obj2, &val3);
7600 if (!SWIG_IsOK(ecode3)) {
7601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7602 }
7603 arg3 = static_cast< int >(val3);
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 (arg1)->SetColAttr(arg2,arg3);
7607 wxPyEndAllowThreads(__tstate);
7608 if (PyErr_Occurred()) SWIG_fail;
7609 }
7610 resultobj = SWIG_Py_Void();
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *obj;
7619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7620 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7621 return SWIG_Py_Void();
7622 }
7623
7624 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7625 return SWIG_Python_InitShadowInstance(args);
7626 }
7627
7628 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7629 PyObject *resultobj = 0;
7630 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7631 PyObject *arg2 = (PyObject *) 0 ;
7632 void *argp1 = 0 ;
7633 int res1 = 0 ;
7634 PyObject * obj0 = 0 ;
7635 PyObject * obj1 = 0 ;
7636 char * kwnames[] = {
7637 (char *) "self",(char *) "_self", NULL
7638 };
7639
7640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7642 if (!SWIG_IsOK(res1)) {
7643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7644 }
7645 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7646 arg2 = obj1;
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 wxGridTableBase__setOORInfo(arg1,arg2);
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 resultobj = SWIG_Py_Void();
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7663 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 void *argp2 = 0 ;
7667 int res2 = 0 ;
7668 PyObject * obj0 = 0 ;
7669 PyObject * obj1 = 0 ;
7670 char * kwnames[] = {
7671 (char *) "self",(char *) "attrProvider", NULL
7672 };
7673
7674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7678 }
7679 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7681 if (!SWIG_IsOK(res2)) {
7682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7683 }
7684 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7685 {
7686 PyThreadState* __tstate = wxPyBeginAllowThreads();
7687 (arg1)->SetAttrProvider(arg2);
7688 wxPyEndAllowThreads(__tstate);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 resultobj = SWIG_Py_Void();
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7699 PyObject *resultobj = 0;
7700 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7701 wxGridCellAttrProvider *result = 0 ;
7702 void *argp1 = 0 ;
7703 int res1 = 0 ;
7704 PyObject *swig_obj[1] ;
7705
7706 if (!args) SWIG_fail;
7707 swig_obj[0] = args;
7708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7709 if (!SWIG_IsOK(res1)) {
7710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7711 }
7712 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7713 {
7714 PyThreadState* __tstate = wxPyBeginAllowThreads();
7715 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj = 0;
7730 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7731 wxGrid *arg2 = (wxGrid *) 0 ;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 void *argp2 = 0 ;
7735 int res2 = 0 ;
7736 PyObject * obj0 = 0 ;
7737 PyObject * obj1 = 0 ;
7738 char * kwnames[] = {
7739 (char *) "self",(char *) "grid", NULL
7740 };
7741
7742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7744 if (!SWIG_IsOK(res1)) {
7745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7746 }
7747 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7749 if (!SWIG_IsOK(res2)) {
7750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7751 }
7752 arg2 = reinterpret_cast< wxGrid * >(argp2);
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 (arg1)->SetView(arg2);
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 resultobj = SWIG_Py_Void();
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7767 PyObject *resultobj = 0;
7768 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7769 wxGrid *result = 0 ;
7770 void *argp1 = 0 ;
7771 int res1 = 0 ;
7772 PyObject *swig_obj[1] ;
7773
7774 if (!args) SWIG_fail;
7775 swig_obj[0] = args;
7776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7777 if (!SWIG_IsOK(res1)) {
7778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7779 }
7780 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7781 {
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 {
7788 resultobj = wxPyMake_wxObject(result, (bool)0);
7789 }
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 PyObject *resultobj = 0;
7798 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7799 int result;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 PyObject *swig_obj[1] ;
7803
7804 if (!args) SWIG_fail;
7805 swig_obj[0] = args;
7806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7809 }
7810 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (int)(arg1)->GetNumberRows();
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = SWIG_From_int(static_cast< int >(result));
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *resultobj = 0;
7826 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7827 int result;
7828 void *argp1 = 0 ;
7829 int res1 = 0 ;
7830 PyObject *swig_obj[1] ;
7831
7832 if (!args) SWIG_fail;
7833 swig_obj[0] = args;
7834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7837 }
7838 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 result = (int)(arg1)->GetNumberCols();
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_From_int(static_cast< int >(result));
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = 0;
7854 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7855 int arg2 ;
7856 int arg3 ;
7857 bool result;
7858 void *argp1 = 0 ;
7859 int res1 = 0 ;
7860 int val2 ;
7861 int ecode2 = 0 ;
7862 int val3 ;
7863 int ecode3 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 PyObject * obj2 = 0 ;
7867 char * kwnames[] = {
7868 (char *) "self",(char *) "row",(char *) "col", NULL
7869 };
7870
7871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7875 }
7876 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7877 ecode2 = SWIG_AsVal_int(obj1, &val2);
7878 if (!SWIG_IsOK(ecode2)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7880 }
7881 arg2 = static_cast< int >(val2);
7882 ecode3 = SWIG_AsVal_int(obj2, &val3);
7883 if (!SWIG_IsOK(ecode3)) {
7884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7885 }
7886 arg3 = static_cast< int >(val3);
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 {
7894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7895 }
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj = 0;
7904 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7905 int arg2 ;
7906 int arg3 ;
7907 wxString result;
7908 void *argp1 = 0 ;
7909 int res1 = 0 ;
7910 int val2 ;
7911 int ecode2 = 0 ;
7912 int val3 ;
7913 int ecode3 = 0 ;
7914 PyObject * obj0 = 0 ;
7915 PyObject * obj1 = 0 ;
7916 PyObject * obj2 = 0 ;
7917 char * kwnames[] = {
7918 (char *) "self",(char *) "row",(char *) "col", NULL
7919 };
7920
7921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7923 if (!SWIG_IsOK(res1)) {
7924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7925 }
7926 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7927 ecode2 = SWIG_AsVal_int(obj1, &val2);
7928 if (!SWIG_IsOK(ecode2)) {
7929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7930 }
7931 arg2 = static_cast< int >(val2);
7932 ecode3 = SWIG_AsVal_int(obj2, &val3);
7933 if (!SWIG_IsOK(ecode3)) {
7934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7935 }
7936 arg3 = static_cast< int >(val3);
7937 {
7938 PyThreadState* __tstate = wxPyBeginAllowThreads();
7939 result = (arg1)->GetValue(arg2,arg3);
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 {
7944 #if wxUSE_UNICODE
7945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7946 #else
7947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7948 #endif
7949 }
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj = 0;
7958 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7959 int arg2 ;
7960 int arg3 ;
7961 wxString *arg4 = 0 ;
7962 void *argp1 = 0 ;
7963 int res1 = 0 ;
7964 int val2 ;
7965 int ecode2 = 0 ;
7966 int val3 ;
7967 int ecode3 = 0 ;
7968 bool temp4 = false ;
7969 PyObject * obj0 = 0 ;
7970 PyObject * obj1 = 0 ;
7971 PyObject * obj2 = 0 ;
7972 PyObject * obj3 = 0 ;
7973 char * kwnames[] = {
7974 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
7975 };
7976
7977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7979 if (!SWIG_IsOK(res1)) {
7980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7981 }
7982 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7983 ecode2 = SWIG_AsVal_int(obj1, &val2);
7984 if (!SWIG_IsOK(ecode2)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
7986 }
7987 arg2 = static_cast< int >(val2);
7988 ecode3 = SWIG_AsVal_int(obj2, &val3);
7989 if (!SWIG_IsOK(ecode3)) {
7990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
7991 }
7992 arg3 = static_cast< int >(val3);
7993 {
7994 arg4 = wxString_in_helper(obj3);
7995 if (arg4 == NULL) SWIG_fail;
7996 temp4 = true;
7997 }
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_Py_Void();
8005 {
8006 if (temp4)
8007 delete arg4;
8008 }
8009 return resultobj;
8010 fail:
8011 {
8012 if (temp4)
8013 delete arg4;
8014 }
8015 return NULL;
8016 }
8017
8018
8019 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj = 0;
8021 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8022 int arg2 ;
8023 int arg3 ;
8024 wxString result;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 int val2 ;
8028 int ecode2 = 0 ;
8029 int val3 ;
8030 int ecode3 = 0 ;
8031 PyObject * obj0 = 0 ;
8032 PyObject * obj1 = 0 ;
8033 PyObject * obj2 = 0 ;
8034 char * kwnames[] = {
8035 (char *) "self",(char *) "row",(char *) "col", NULL
8036 };
8037
8038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8040 if (!SWIG_IsOK(res1)) {
8041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8042 }
8043 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8044 ecode2 = SWIG_AsVal_int(obj1, &val2);
8045 if (!SWIG_IsOK(ecode2)) {
8046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8047 }
8048 arg2 = static_cast< int >(val2);
8049 ecode3 = SWIG_AsVal_int(obj2, &val3);
8050 if (!SWIG_IsOK(ecode3)) {
8051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8052 }
8053 arg3 = static_cast< int >(val3);
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 result = (arg1)->GetTypeName(arg2,arg3);
8057 wxPyEndAllowThreads(__tstate);
8058 if (PyErr_Occurred()) SWIG_fail;
8059 }
8060 {
8061 #if wxUSE_UNICODE
8062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8063 #else
8064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8065 #endif
8066 }
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8076 int arg2 ;
8077 int arg3 ;
8078 wxString *arg4 = 0 ;
8079 bool result;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 int val2 ;
8083 int ecode2 = 0 ;
8084 int val3 ;
8085 int ecode3 = 0 ;
8086 bool temp4 = false ;
8087 PyObject * obj0 = 0 ;
8088 PyObject * obj1 = 0 ;
8089 PyObject * obj2 = 0 ;
8090 PyObject * obj3 = 0 ;
8091 char * kwnames[] = {
8092 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8093 };
8094
8095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8097 if (!SWIG_IsOK(res1)) {
8098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8099 }
8100 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8101 ecode2 = SWIG_AsVal_int(obj1, &val2);
8102 if (!SWIG_IsOK(ecode2)) {
8103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8104 }
8105 arg2 = static_cast< int >(val2);
8106 ecode3 = SWIG_AsVal_int(obj2, &val3);
8107 if (!SWIG_IsOK(ecode3)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8109 }
8110 arg3 = static_cast< int >(val3);
8111 {
8112 arg4 = wxString_in_helper(obj3);
8113 if (arg4 == NULL) SWIG_fail;
8114 temp4 = true;
8115 }
8116 {
8117 PyThreadState* __tstate = wxPyBeginAllowThreads();
8118 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8119 wxPyEndAllowThreads(__tstate);
8120 if (PyErr_Occurred()) SWIG_fail;
8121 }
8122 {
8123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8124 }
8125 {
8126 if (temp4)
8127 delete arg4;
8128 }
8129 return resultobj;
8130 fail:
8131 {
8132 if (temp4)
8133 delete arg4;
8134 }
8135 return NULL;
8136 }
8137
8138
8139 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8140 PyObject *resultobj = 0;
8141 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8142 int arg2 ;
8143 int arg3 ;
8144 wxString *arg4 = 0 ;
8145 bool result;
8146 void *argp1 = 0 ;
8147 int res1 = 0 ;
8148 int val2 ;
8149 int ecode2 = 0 ;
8150 int val3 ;
8151 int ecode3 = 0 ;
8152 bool temp4 = false ;
8153 PyObject * obj0 = 0 ;
8154 PyObject * obj1 = 0 ;
8155 PyObject * obj2 = 0 ;
8156 PyObject * obj3 = 0 ;
8157 char * kwnames[] = {
8158 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8159 };
8160
8161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8163 if (!SWIG_IsOK(res1)) {
8164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8165 }
8166 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8167 ecode2 = SWIG_AsVal_int(obj1, &val2);
8168 if (!SWIG_IsOK(ecode2)) {
8169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8170 }
8171 arg2 = static_cast< int >(val2);
8172 ecode3 = SWIG_AsVal_int(obj2, &val3);
8173 if (!SWIG_IsOK(ecode3)) {
8174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8175 }
8176 arg3 = static_cast< int >(val3);
8177 {
8178 arg4 = wxString_in_helper(obj3);
8179 if (arg4 == NULL) SWIG_fail;
8180 temp4 = true;
8181 }
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 {
8189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8190 }
8191 {
8192 if (temp4)
8193 delete arg4;
8194 }
8195 return resultobj;
8196 fail:
8197 {
8198 if (temp4)
8199 delete arg4;
8200 }
8201 return NULL;
8202 }
8203
8204
8205 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj = 0;
8207 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8208 int arg2 ;
8209 int arg3 ;
8210 long result;
8211 void *argp1 = 0 ;
8212 int res1 = 0 ;
8213 int val2 ;
8214 int ecode2 = 0 ;
8215 int val3 ;
8216 int ecode3 = 0 ;
8217 PyObject * obj0 = 0 ;
8218 PyObject * obj1 = 0 ;
8219 PyObject * obj2 = 0 ;
8220 char * kwnames[] = {
8221 (char *) "self",(char *) "row",(char *) "col", NULL
8222 };
8223
8224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8226 if (!SWIG_IsOK(res1)) {
8227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8228 }
8229 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8230 ecode2 = SWIG_AsVal_int(obj1, &val2);
8231 if (!SWIG_IsOK(ecode2)) {
8232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8233 }
8234 arg2 = static_cast< int >(val2);
8235 ecode3 = SWIG_AsVal_int(obj2, &val3);
8236 if (!SWIG_IsOK(ecode3)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8238 }
8239 arg3 = static_cast< int >(val3);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_From_long(static_cast< long >(result));
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj = 0;
8255 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8256 int arg2 ;
8257 int arg3 ;
8258 double result;
8259 void *argp1 = 0 ;
8260 int res1 = 0 ;
8261 int val2 ;
8262 int ecode2 = 0 ;
8263 int val3 ;
8264 int ecode3 = 0 ;
8265 PyObject * obj0 = 0 ;
8266 PyObject * obj1 = 0 ;
8267 PyObject * obj2 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "self",(char *) "row",(char *) "col", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8274 if (!SWIG_IsOK(res1)) {
8275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8276 }
8277 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8278 ecode2 = SWIG_AsVal_int(obj1, &val2);
8279 if (!SWIG_IsOK(ecode2)) {
8280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8281 }
8282 arg2 = static_cast< int >(val2);
8283 ecode3 = SWIG_AsVal_int(obj2, &val3);
8284 if (!SWIG_IsOK(ecode3)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8286 }
8287 arg3 = static_cast< int >(val3);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = SWIG_From_double(static_cast< double >(result));
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8304 int arg2 ;
8305 int arg3 ;
8306 bool result;
8307 void *argp1 = 0 ;
8308 int res1 = 0 ;
8309 int val2 ;
8310 int ecode2 = 0 ;
8311 int val3 ;
8312 int ecode3 = 0 ;
8313 PyObject * obj0 = 0 ;
8314 PyObject * obj1 = 0 ;
8315 PyObject * obj2 = 0 ;
8316 char * kwnames[] = {
8317 (char *) "self",(char *) "row",(char *) "col", NULL
8318 };
8319
8320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8324 }
8325 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8326 ecode2 = SWIG_AsVal_int(obj1, &val2);
8327 if (!SWIG_IsOK(ecode2)) {
8328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8329 }
8330 arg2 = static_cast< int >(val2);
8331 ecode3 = SWIG_AsVal_int(obj2, &val3);
8332 if (!SWIG_IsOK(ecode3)) {
8333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8334 }
8335 arg3 = static_cast< int >(val3);
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 {
8343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8344 }
8345 return resultobj;
8346 fail:
8347 return NULL;
8348 }
8349
8350
8351 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj = 0;
8353 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8354 int arg2 ;
8355 int arg3 ;
8356 long arg4 ;
8357 void *argp1 = 0 ;
8358 int res1 = 0 ;
8359 int val2 ;
8360 int ecode2 = 0 ;
8361 int val3 ;
8362 int ecode3 = 0 ;
8363 long val4 ;
8364 int ecode4 = 0 ;
8365 PyObject * obj0 = 0 ;
8366 PyObject * obj1 = 0 ;
8367 PyObject * obj2 = 0 ;
8368 PyObject * obj3 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8377 }
8378 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8379 ecode2 = SWIG_AsVal_int(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8382 }
8383 arg2 = static_cast< int >(val2);
8384 ecode3 = SWIG_AsVal_int(obj2, &val3);
8385 if (!SWIG_IsOK(ecode3)) {
8386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8387 }
8388 arg3 = static_cast< int >(val3);
8389 ecode4 = SWIG_AsVal_long(obj3, &val4);
8390 if (!SWIG_IsOK(ecode4)) {
8391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8392 }
8393 arg4 = static_cast< long >(val4);
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8397 wxPyEndAllowThreads(__tstate);
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 resultobj = SWIG_Py_Void();
8401 return resultobj;
8402 fail:
8403 return NULL;
8404 }
8405
8406
8407 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8408 PyObject *resultobj = 0;
8409 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8410 int arg2 ;
8411 int arg3 ;
8412 double arg4 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 int val2 ;
8416 int ecode2 = 0 ;
8417 int val3 ;
8418 int ecode3 = 0 ;
8419 double val4 ;
8420 int ecode4 = 0 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 PyObject * obj2 = 0 ;
8424 PyObject * obj3 = 0 ;
8425 char * kwnames[] = {
8426 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8427 };
8428
8429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8433 }
8434 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8435 ecode2 = SWIG_AsVal_int(obj1, &val2);
8436 if (!SWIG_IsOK(ecode2)) {
8437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8438 }
8439 arg2 = static_cast< int >(val2);
8440 ecode3 = SWIG_AsVal_int(obj2, &val3);
8441 if (!SWIG_IsOK(ecode3)) {
8442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8443 }
8444 arg3 = static_cast< int >(val3);
8445 ecode4 = SWIG_AsVal_double(obj3, &val4);
8446 if (!SWIG_IsOK(ecode4)) {
8447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8448 }
8449 arg4 = static_cast< double >(val4);
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 resultobj = SWIG_Py_Void();
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8464 PyObject *resultobj = 0;
8465 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8466 int arg2 ;
8467 int arg3 ;
8468 bool arg4 ;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 int val2 ;
8472 int ecode2 = 0 ;
8473 int val3 ;
8474 int ecode3 = 0 ;
8475 bool val4 ;
8476 int ecode4 = 0 ;
8477 PyObject * obj0 = 0 ;
8478 PyObject * obj1 = 0 ;
8479 PyObject * obj2 = 0 ;
8480 PyObject * obj3 = 0 ;
8481 char * kwnames[] = {
8482 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8483 };
8484
8485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8487 if (!SWIG_IsOK(res1)) {
8488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8489 }
8490 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8491 ecode2 = SWIG_AsVal_int(obj1, &val2);
8492 if (!SWIG_IsOK(ecode2)) {
8493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8494 }
8495 arg2 = static_cast< int >(val2);
8496 ecode3 = SWIG_AsVal_int(obj2, &val3);
8497 if (!SWIG_IsOK(ecode3)) {
8498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8499 }
8500 arg3 = static_cast< int >(val3);
8501 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8502 if (!SWIG_IsOK(ecode4)) {
8503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8504 }
8505 arg4 = static_cast< bool >(val4);
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_Py_Void();
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8520 PyObject *resultobj = 0;
8521 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 PyObject *swig_obj[1] ;
8525
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8531 }
8532 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 (arg1)->Clear();
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_Py_Void();
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8547 PyObject *resultobj = 0;
8548 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8549 size_t arg2 = (size_t) 0 ;
8550 size_t arg3 = (size_t) 1 ;
8551 bool result;
8552 void *argp1 = 0 ;
8553 int res1 = 0 ;
8554 size_t val2 ;
8555 int ecode2 = 0 ;
8556 size_t val3 ;
8557 int ecode3 = 0 ;
8558 PyObject * obj0 = 0 ;
8559 PyObject * obj1 = 0 ;
8560 PyObject * obj2 = 0 ;
8561 char * kwnames[] = {
8562 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8563 };
8564
8565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8567 if (!SWIG_IsOK(res1)) {
8568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8569 }
8570 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8571 if (obj1) {
8572 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8573 if (!SWIG_IsOK(ecode2)) {
8574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8575 }
8576 arg2 = static_cast< size_t >(val2);
8577 }
8578 if (obj2) {
8579 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8580 if (!SWIG_IsOK(ecode3)) {
8581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8582 }
8583 arg3 = static_cast< size_t >(val3);
8584 }
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 result = (bool)(arg1)->InsertRows(arg2,arg3);
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 {
8592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8593 }
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj = 0;
8602 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8603 size_t arg2 = (size_t) 1 ;
8604 bool result;
8605 void *argp1 = 0 ;
8606 int res1 = 0 ;
8607 size_t val2 ;
8608 int ecode2 = 0 ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 char * kwnames[] = {
8612 (char *) "self",(char *) "numRows", NULL
8613 };
8614
8615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8617 if (!SWIG_IsOK(res1)) {
8618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8619 }
8620 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8621 if (obj1) {
8622 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8623 if (!SWIG_IsOK(ecode2)) {
8624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8625 }
8626 arg2 = static_cast< size_t >(val2);
8627 }
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (bool)(arg1)->AppendRows(arg2);
8631 wxPyEndAllowThreads(__tstate);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 {
8635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8636 }
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj = 0;
8645 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8646 size_t arg2 = (size_t) 0 ;
8647 size_t arg3 = (size_t) 1 ;
8648 bool result;
8649 void *argp1 = 0 ;
8650 int res1 = 0 ;
8651 size_t val2 ;
8652 int ecode2 = 0 ;
8653 size_t val3 ;
8654 int ecode3 = 0 ;
8655 PyObject * obj0 = 0 ;
8656 PyObject * obj1 = 0 ;
8657 PyObject * obj2 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8666 }
8667 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8668 if (obj1) {
8669 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8670 if (!SWIG_IsOK(ecode2)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8672 }
8673 arg2 = static_cast< size_t >(val2);
8674 }
8675 if (obj2) {
8676 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8677 if (!SWIG_IsOK(ecode3)) {
8678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8679 }
8680 arg3 = static_cast< size_t >(val3);
8681 }
8682 {
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8685 wxPyEndAllowThreads(__tstate);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 {
8689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8690 }
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8698 PyObject *resultobj = 0;
8699 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8700 size_t arg2 = (size_t) 0 ;
8701 size_t arg3 = (size_t) 1 ;
8702 bool result;
8703 void *argp1 = 0 ;
8704 int res1 = 0 ;
8705 size_t val2 ;
8706 int ecode2 = 0 ;
8707 size_t val3 ;
8708 int ecode3 = 0 ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 PyObject * obj2 = 0 ;
8712 char * kwnames[] = {
8713 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8714 };
8715
8716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8718 if (!SWIG_IsOK(res1)) {
8719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8720 }
8721 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8722 if (obj1) {
8723 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8724 if (!SWIG_IsOK(ecode2)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8726 }
8727 arg2 = static_cast< size_t >(val2);
8728 }
8729 if (obj2) {
8730 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8731 if (!SWIG_IsOK(ecode3)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8733 }
8734 arg3 = static_cast< size_t >(val3);
8735 }
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (bool)(arg1)->InsertCols(arg2,arg3);
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = 0;
8753 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8754 size_t arg2 = (size_t) 1 ;
8755 bool result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 size_t val2 ;
8759 int ecode2 = 0 ;
8760 PyObject * obj0 = 0 ;
8761 PyObject * obj1 = 0 ;
8762 char * kwnames[] = {
8763 (char *) "self",(char *) "numCols", NULL
8764 };
8765
8766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8770 }
8771 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8772 if (obj1) {
8773 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8774 if (!SWIG_IsOK(ecode2)) {
8775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8776 }
8777 arg2 = static_cast< size_t >(val2);
8778 }
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 result = (bool)(arg1)->AppendCols(arg2);
8782 wxPyEndAllowThreads(__tstate);
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 {
8786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8787 }
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj = 0;
8796 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8797 size_t arg2 = (size_t) 0 ;
8798 size_t arg3 = (size_t) 1 ;
8799 bool result;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 size_t val2 ;
8803 int ecode2 = 0 ;
8804 size_t val3 ;
8805 int ecode3 = 0 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 PyObject * obj2 = 0 ;
8809 char * kwnames[] = {
8810 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8811 };
8812
8813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8817 }
8818 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8819 if (obj1) {
8820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8823 }
8824 arg2 = static_cast< size_t >(val2);
8825 }
8826 if (obj2) {
8827 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8828 if (!SWIG_IsOK(ecode3)) {
8829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8830 }
8831 arg3 = static_cast< size_t >(val3);
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 {
8840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8841 }
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj = 0;
8850 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8851 int arg2 ;
8852 wxString result;
8853 void *argp1 = 0 ;
8854 int res1 = 0 ;
8855 int val2 ;
8856 int ecode2 = 0 ;
8857 PyObject * obj0 = 0 ;
8858 PyObject * obj1 = 0 ;
8859 char * kwnames[] = {
8860 (char *) "self",(char *) "row", NULL
8861 };
8862
8863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8867 }
8868 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8869 ecode2 = SWIG_AsVal_int(obj1, &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8872 }
8873 arg2 = static_cast< int >(val2);
8874 {
8875 PyThreadState* __tstate = wxPyBeginAllowThreads();
8876 result = (arg1)->GetRowLabelValue(arg2);
8877 wxPyEndAllowThreads(__tstate);
8878 if (PyErr_Occurred()) SWIG_fail;
8879 }
8880 {
8881 #if wxUSE_UNICODE
8882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8883 #else
8884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8885 #endif
8886 }
8887 return resultobj;
8888 fail:
8889 return NULL;
8890 }
8891
8892
8893 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8894 PyObject *resultobj = 0;
8895 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8896 int arg2 ;
8897 wxString result;
8898 void *argp1 = 0 ;
8899 int res1 = 0 ;
8900 int val2 ;
8901 int ecode2 = 0 ;
8902 PyObject * obj0 = 0 ;
8903 PyObject * obj1 = 0 ;
8904 char * kwnames[] = {
8905 (char *) "self",(char *) "col", NULL
8906 };
8907
8908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8912 }
8913 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8914 ecode2 = SWIG_AsVal_int(obj1, &val2);
8915 if (!SWIG_IsOK(ecode2)) {
8916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8917 }
8918 arg2 = static_cast< int >(val2);
8919 {
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 result = (arg1)->GetColLabelValue(arg2);
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 {
8926 #if wxUSE_UNICODE
8927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8928 #else
8929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8930 #endif
8931 }
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8939 PyObject *resultobj = 0;
8940 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8941 int arg2 ;
8942 wxString *arg3 = 0 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 int val2 ;
8946 int ecode2 = 0 ;
8947 bool temp3 = false ;
8948 PyObject * obj0 = 0 ;
8949 PyObject * obj1 = 0 ;
8950 PyObject * obj2 = 0 ;
8951 char * kwnames[] = {
8952 (char *) "self",(char *) "row",(char *) "value", NULL
8953 };
8954
8955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8959 }
8960 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8961 ecode2 = SWIG_AsVal_int(obj1, &val2);
8962 if (!SWIG_IsOK(ecode2)) {
8963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8964 }
8965 arg2 = static_cast< int >(val2);
8966 {
8967 arg3 = wxString_in_helper(obj2);
8968 if (arg3 == NULL) SWIG_fail;
8969 temp3 = true;
8970 }
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = SWIG_Py_Void();
8978 {
8979 if (temp3)
8980 delete arg3;
8981 }
8982 return resultobj;
8983 fail:
8984 {
8985 if (temp3)
8986 delete arg3;
8987 }
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj = 0;
8994 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8995 int arg2 ;
8996 wxString *arg3 = 0 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 int val2 ;
9000 int ecode2 = 0 ;
9001 bool temp3 = false ;
9002 PyObject * obj0 = 0 ;
9003 PyObject * obj1 = 0 ;
9004 PyObject * obj2 = 0 ;
9005 char * kwnames[] = {
9006 (char *) "self",(char *) "col",(char *) "value", NULL
9007 };
9008
9009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9011 if (!SWIG_IsOK(res1)) {
9012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9013 }
9014 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9015 ecode2 = SWIG_AsVal_int(obj1, &val2);
9016 if (!SWIG_IsOK(ecode2)) {
9017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9018 }
9019 arg2 = static_cast< int >(val2);
9020 {
9021 arg3 = wxString_in_helper(obj2);
9022 if (arg3 == NULL) SWIG_fail;
9023 temp3 = true;
9024 }
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 resultobj = SWIG_Py_Void();
9032 {
9033 if (temp3)
9034 delete arg3;
9035 }
9036 return resultobj;
9037 fail:
9038 {
9039 if (temp3)
9040 delete arg3;
9041 }
9042 return NULL;
9043 }
9044
9045
9046 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9047 PyObject *resultobj = 0;
9048 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9049 bool result;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject *swig_obj[1] ;
9053
9054 if (!args) SWIG_fail;
9055 swig_obj[0] = args;
9056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9059 }
9060 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (bool)(arg1)->CanHaveAttributes();
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 {
9068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9069 }
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9077 PyObject *resultobj = 0;
9078 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9079 int arg2 ;
9080 int arg3 ;
9081 wxGridCellAttr::wxAttrKind arg4 ;
9082 wxGridCellAttr *result = 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 int val2 ;
9086 int ecode2 = 0 ;
9087 int val3 ;
9088 int ecode3 = 0 ;
9089 int val4 ;
9090 int ecode4 = 0 ;
9091 PyObject * obj0 = 0 ;
9092 PyObject * obj1 = 0 ;
9093 PyObject * obj2 = 0 ;
9094 PyObject * obj3 = 0 ;
9095 char * kwnames[] = {
9096 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9097 };
9098
9099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9103 }
9104 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9105 ecode2 = SWIG_AsVal_int(obj1, &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9108 }
9109 arg2 = static_cast< int >(val2);
9110 ecode3 = SWIG_AsVal_int(obj2, &val3);
9111 if (!SWIG_IsOK(ecode3)) {
9112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9113 }
9114 arg3 = static_cast< int >(val3);
9115 ecode4 = SWIG_AsVal_int(obj3, &val4);
9116 if (!SWIG_IsOK(ecode4)) {
9117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9118 }
9119 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9120 {
9121 PyThreadState* __tstate = wxPyBeginAllowThreads();
9122 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9123 wxPyEndAllowThreads(__tstate);
9124 if (PyErr_Occurred()) SWIG_fail;
9125 }
9126 {
9127 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9128 }
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj = 0;
9137 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9138 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9139 int arg3 ;
9140 int arg4 ;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 void *argp2 = 0 ;
9144 int res2 = 0 ;
9145 int val3 ;
9146 int ecode3 = 0 ;
9147 int val4 ;
9148 int ecode4 = 0 ;
9149 PyObject * obj0 = 0 ;
9150 PyObject * obj1 = 0 ;
9151 PyObject * obj2 = 0 ;
9152 PyObject * obj3 = 0 ;
9153 char * kwnames[] = {
9154 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9155 };
9156
9157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9161 }
9162 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9163 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9164 if (!SWIG_IsOK(res2)) {
9165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9166 }
9167 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9168 ecode3 = SWIG_AsVal_int(obj2, &val3);
9169 if (!SWIG_IsOK(ecode3)) {
9170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9171 }
9172 arg3 = static_cast< int >(val3);
9173 ecode4 = SWIG_AsVal_int(obj3, &val4);
9174 if (!SWIG_IsOK(ecode4)) {
9175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9176 }
9177 arg4 = static_cast< int >(val4);
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 (arg1)->SetAttr(arg2,arg3,arg4);
9181 wxPyEndAllowThreads(__tstate);
9182 if (PyErr_Occurred()) SWIG_fail;
9183 }
9184 resultobj = SWIG_Py_Void();
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9192 PyObject *resultobj = 0;
9193 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9194 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9195 int arg3 ;
9196 void *argp1 = 0 ;
9197 int res1 = 0 ;
9198 void *argp2 = 0 ;
9199 int res2 = 0 ;
9200 int val3 ;
9201 int ecode3 = 0 ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 PyObject * obj2 = 0 ;
9205 char * kwnames[] = {
9206 (char *) "self",(char *) "attr",(char *) "row", NULL
9207 };
9208
9209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9211 if (!SWIG_IsOK(res1)) {
9212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9213 }
9214 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9216 if (!SWIG_IsOK(res2)) {
9217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9218 }
9219 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9220 ecode3 = SWIG_AsVal_int(obj2, &val3);
9221 if (!SWIG_IsOK(ecode3)) {
9222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9223 }
9224 arg3 = static_cast< int >(val3);
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 (arg1)->SetRowAttr(arg2,arg3);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_Py_Void();
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj = 0;
9240 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9241 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9242 int arg3 ;
9243 void *argp1 = 0 ;
9244 int res1 = 0 ;
9245 void *argp2 = 0 ;
9246 int res2 = 0 ;
9247 int val3 ;
9248 int ecode3 = 0 ;
9249 PyObject * obj0 = 0 ;
9250 PyObject * obj1 = 0 ;
9251 PyObject * obj2 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "attr",(char *) "col", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9260 }
9261 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9263 if (!SWIG_IsOK(res2)) {
9264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9265 }
9266 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9267 ecode3 = SWIG_AsVal_int(obj2, &val3);
9268 if (!SWIG_IsOK(ecode3)) {
9269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9270 }
9271 arg3 = static_cast< int >(val3);
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 (arg1)->SetColAttr(arg2,arg3);
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_Py_Void();
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *obj;
9287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9288 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9289 return SWIG_Py_Void();
9290 }
9291
9292 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9293 PyObject *resultobj = 0;
9294 wxPyGridTableBase *result = 0 ;
9295
9296 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9311 PyObject *resultobj = 0;
9312 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9313 PyObject *arg2 = (PyObject *) 0 ;
9314 PyObject *arg3 = (PyObject *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject * obj0 = 0 ;
9318 PyObject * obj1 = 0 ;
9319 PyObject * obj2 = 0 ;
9320 char * kwnames[] = {
9321 (char *) "self",(char *) "self",(char *) "_class", NULL
9322 };
9323
9324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9326 if (!SWIG_IsOK(res1)) {
9327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9328 }
9329 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9330 arg2 = obj1;
9331 arg3 = obj2;
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 (arg1)->_setCallbackInfo(arg2,arg3);
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 resultobj = SWIG_Py_Void();
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9346 PyObject *resultobj = 0;
9347 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9357 }
9358 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 wxPyGridTableBase_Destroy(arg1);
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_Py_Void();
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *obj;
9374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9375 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9376 return SWIG_Py_Void();
9377 }
9378
9379 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 return SWIG_Python_InitShadowInstance(args);
9381 }
9382
9383 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9384 PyObject *resultobj = 0;
9385 int arg1 = (int) 0 ;
9386 int arg2 = (int) 0 ;
9387 wxGridStringTable *result = 0 ;
9388 int val1 ;
9389 int ecode1 = 0 ;
9390 int val2 ;
9391 int ecode2 = 0 ;
9392 PyObject * obj0 = 0 ;
9393 PyObject * obj1 = 0 ;
9394 char * kwnames[] = {
9395 (char *) "numRows",(char *) "numCols", NULL
9396 };
9397
9398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9399 if (obj0) {
9400 ecode1 = SWIG_AsVal_int(obj0, &val1);
9401 if (!SWIG_IsOK(ecode1)) {
9402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9403 }
9404 arg1 = static_cast< int >(val1);
9405 }
9406 if (obj1) {
9407 ecode2 = SWIG_AsVal_int(obj1, &val2);
9408 if (!SWIG_IsOK(ecode2)) {
9409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9410 }
9411 arg2 = static_cast< int >(val2);
9412 }
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9420 return resultobj;
9421 fail:
9422 return NULL;
9423 }
9424
9425
9426 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 PyObject *obj;
9428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9429 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9430 return SWIG_Py_Void();
9431 }
9432
9433 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434 return SWIG_Python_InitShadowInstance(args);
9435 }
9436
9437 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9440 int arg2 ;
9441 int arg3 = (int) -1 ;
9442 int arg4 = (int) -1 ;
9443 wxGridTableMessage *result = 0 ;
9444 void *argp1 = 0 ;
9445 int res1 = 0 ;
9446 int val2 ;
9447 int ecode2 = 0 ;
9448 int val3 ;
9449 int ecode3 = 0 ;
9450 int val4 ;
9451 int ecode4 = 0 ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 PyObject * obj2 = 0 ;
9455 PyObject * obj3 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9464 }
9465 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9466 ecode2 = SWIG_AsVal_int(obj1, &val2);
9467 if (!SWIG_IsOK(ecode2)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9469 }
9470 arg2 = static_cast< int >(val2);
9471 if (obj2) {
9472 ecode3 = SWIG_AsVal_int(obj2, &val3);
9473 if (!SWIG_IsOK(ecode3)) {
9474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9475 }
9476 arg3 = static_cast< int >(val3);
9477 }
9478 if (obj3) {
9479 ecode4 = SWIG_AsVal_int(obj3, &val4);
9480 if (!SWIG_IsOK(ecode4)) {
9481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9482 }
9483 arg4 = static_cast< int >(val4);
9484 }
9485 {
9486 PyThreadState* __tstate = wxPyBeginAllowThreads();
9487 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9488 wxPyEndAllowThreads(__tstate);
9489 if (PyErr_Occurred()) SWIG_fail;
9490 }
9491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9492 return resultobj;
9493 fail:
9494 return NULL;
9495 }
9496
9497
9498 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9499 PyObject *resultobj = 0;
9500 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9501 void *argp1 = 0 ;
9502 int res1 = 0 ;
9503 PyObject *swig_obj[1] ;
9504
9505 if (!args) SWIG_fail;
9506 swig_obj[0] = args;
9507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9510 }
9511 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 delete arg1;
9515
9516 wxPyEndAllowThreads(__tstate);
9517 if (PyErr_Occurred()) SWIG_fail;
9518 }
9519 resultobj = SWIG_Py_Void();
9520 return resultobj;
9521 fail:
9522 return NULL;
9523 }
9524
9525
9526 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj = 0;
9528 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9529 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9530 void *argp1 = 0 ;
9531 int res1 = 0 ;
9532 void *argp2 = 0 ;
9533 int res2 = 0 ;
9534 PyObject * obj0 = 0 ;
9535 PyObject * obj1 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "self",(char *) "table", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9544 }
9545 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9547 if (!SWIG_IsOK(res2)) {
9548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9549 }
9550 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 (arg1)->SetTableObject(arg2);
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_Py_Void();
9558 return resultobj;
9559 fail:
9560 return NULL;
9561 }
9562
9563
9564 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9565 PyObject *resultobj = 0;
9566 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9567 wxGridTableBase *result = 0 ;
9568 void *argp1 = 0 ;
9569 int res1 = 0 ;
9570 PyObject *swig_obj[1] ;
9571
9572 if (!args) SWIG_fail;
9573 swig_obj[0] = args;
9574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9577 }
9578 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9587 }
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj = 0;
9596 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9597 int arg2 ;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 int val2 ;
9601 int ecode2 = 0 ;
9602 PyObject * obj0 = 0 ;
9603 PyObject * obj1 = 0 ;
9604 char * kwnames[] = {
9605 (char *) "self",(char *) "id", NULL
9606 };
9607
9608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9610 if (!SWIG_IsOK(res1)) {
9611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9612 }
9613 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9614 ecode2 = SWIG_AsVal_int(obj1, &val2);
9615 if (!SWIG_IsOK(ecode2)) {
9616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9617 }
9618 arg2 = static_cast< int >(val2);
9619 {
9620 PyThreadState* __tstate = wxPyBeginAllowThreads();
9621 (arg1)->SetId(arg2);
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 resultobj = SWIG_Py_Void();
9626 return resultobj;
9627 fail:
9628 return NULL;
9629 }
9630
9631
9632 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9633 PyObject *resultobj = 0;
9634 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9635 int result;
9636 void *argp1 = 0 ;
9637 int res1 = 0 ;
9638 PyObject *swig_obj[1] ;
9639
9640 if (!args) SWIG_fail;
9641 swig_obj[0] = args;
9642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9643 if (!SWIG_IsOK(res1)) {
9644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9645 }
9646 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9647 {
9648 PyThreadState* __tstate = wxPyBeginAllowThreads();
9649 result = (int)(arg1)->GetId();
9650 wxPyEndAllowThreads(__tstate);
9651 if (PyErr_Occurred()) SWIG_fail;
9652 }
9653 resultobj = SWIG_From_int(static_cast< int >(result));
9654 return resultobj;
9655 fail:
9656 return NULL;
9657 }
9658
9659
9660 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9661 PyObject *resultobj = 0;
9662 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9663 int arg2 ;
9664 void *argp1 = 0 ;
9665 int res1 = 0 ;
9666 int val2 ;
9667 int ecode2 = 0 ;
9668 PyObject * obj0 = 0 ;
9669 PyObject * obj1 = 0 ;
9670 char * kwnames[] = {
9671 (char *) "self",(char *) "comInt1", NULL
9672 };
9673
9674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9678 }
9679 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9680 ecode2 = SWIG_AsVal_int(obj1, &val2);
9681 if (!SWIG_IsOK(ecode2)) {
9682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9683 }
9684 arg2 = static_cast< int >(val2);
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 (arg1)->SetCommandInt(arg2);
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 resultobj = SWIG_Py_Void();
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9699 PyObject *resultobj = 0;
9700 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9701 int result;
9702 void *argp1 = 0 ;
9703 int res1 = 0 ;
9704 PyObject *swig_obj[1] ;
9705
9706 if (!args) SWIG_fail;
9707 swig_obj[0] = args;
9708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9709 if (!SWIG_IsOK(res1)) {
9710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9711 }
9712 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 result = (int)(arg1)->GetCommandInt();
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 resultobj = SWIG_From_int(static_cast< int >(result));
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9727 PyObject *resultobj = 0;
9728 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9729 int arg2 ;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 int val2 ;
9733 int ecode2 = 0 ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 char * kwnames[] = {
9737 (char *) "self",(char *) "comInt2", NULL
9738 };
9739
9740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9742 if (!SWIG_IsOK(res1)) {
9743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9744 }
9745 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9746 ecode2 = SWIG_AsVal_int(obj1, &val2);
9747 if (!SWIG_IsOK(ecode2)) {
9748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9749 }
9750 arg2 = static_cast< int >(val2);
9751 {
9752 PyThreadState* __tstate = wxPyBeginAllowThreads();
9753 (arg1)->SetCommandInt2(arg2);
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 resultobj = SWIG_Py_Void();
9758 return resultobj;
9759 fail:
9760 return NULL;
9761 }
9762
9763
9764 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9765 PyObject *resultobj = 0;
9766 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9767 int result;
9768 void *argp1 = 0 ;
9769 int res1 = 0 ;
9770 PyObject *swig_obj[1] ;
9771
9772 if (!args) SWIG_fail;
9773 swig_obj[0] = args;
9774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9775 if (!SWIG_IsOK(res1)) {
9776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9777 }
9778 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9779 {
9780 PyThreadState* __tstate = wxPyBeginAllowThreads();
9781 result = (int)(arg1)->GetCommandInt2();
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 resultobj = SWIG_From_int(static_cast< int >(result));
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *obj;
9794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9795 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9796 return SWIG_Py_Void();
9797 }
9798
9799 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9800 return SWIG_Python_InitShadowInstance(args);
9801 }
9802
9803 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj = 0;
9805 int arg1 = (int) -1 ;
9806 int arg2 = (int) -1 ;
9807 wxGridCellCoords *result = 0 ;
9808 int val1 ;
9809 int ecode1 = 0 ;
9810 int val2 ;
9811 int ecode2 = 0 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "r",(char *) "c", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9819 if (obj0) {
9820 ecode1 = SWIG_AsVal_int(obj0, &val1);
9821 if (!SWIG_IsOK(ecode1)) {
9822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9823 }
9824 arg1 = static_cast< int >(val1);
9825 }
9826 if (obj1) {
9827 ecode2 = SWIG_AsVal_int(obj1, &val2);
9828 if (!SWIG_IsOK(ecode2)) {
9829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9830 }
9831 arg2 = static_cast< int >(val2);
9832 }
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *resultobj = 0;
9848 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9849 void *argp1 = 0 ;
9850 int res1 = 0 ;
9851 PyObject *swig_obj[1] ;
9852
9853 if (!args) SWIG_fail;
9854 swig_obj[0] = args;
9855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9856 if (!SWIG_IsOK(res1)) {
9857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9858 }
9859 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 delete arg1;
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 resultobj = SWIG_Py_Void();
9868 return resultobj;
9869 fail:
9870 return NULL;
9871 }
9872
9873
9874 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 PyObject *resultobj = 0;
9876 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9877 int result;
9878 void *argp1 = 0 ;
9879 int res1 = 0 ;
9880 PyObject *swig_obj[1] ;
9881
9882 if (!args) SWIG_fail;
9883 swig_obj[0] = args;
9884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9885 if (!SWIG_IsOK(res1)) {
9886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9887 }
9888 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 resultobj = SWIG_From_int(static_cast< int >(result));
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj = 0;
9904 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9905 int arg2 ;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 int val2 ;
9909 int ecode2 = 0 ;
9910 PyObject * obj0 = 0 ;
9911 PyObject * obj1 = 0 ;
9912 char * kwnames[] = {
9913 (char *) "self",(char *) "n", NULL
9914 };
9915
9916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9918 if (!SWIG_IsOK(res1)) {
9919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9920 }
9921 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9922 ecode2 = SWIG_AsVal_int(obj1, &val2);
9923 if (!SWIG_IsOK(ecode2)) {
9924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9925 }
9926 arg2 = static_cast< int >(val2);
9927 {
9928 PyThreadState* __tstate = wxPyBeginAllowThreads();
9929 (arg1)->SetRow(arg2);
9930 wxPyEndAllowThreads(__tstate);
9931 if (PyErr_Occurred()) SWIG_fail;
9932 }
9933 resultobj = SWIG_Py_Void();
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9941 PyObject *resultobj = 0;
9942 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9943 int result;
9944 void *argp1 = 0 ;
9945 int res1 = 0 ;
9946 PyObject *swig_obj[1] ;
9947
9948 if (!args) SWIG_fail;
9949 swig_obj[0] = args;
9950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9953 }
9954 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 resultobj = SWIG_From_int(static_cast< int >(result));
9962 return resultobj;
9963 fail:
9964 return NULL;
9965 }
9966
9967
9968 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9969 PyObject *resultobj = 0;
9970 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9971 int arg2 ;
9972 void *argp1 = 0 ;
9973 int res1 = 0 ;
9974 int val2 ;
9975 int ecode2 = 0 ;
9976 PyObject * obj0 = 0 ;
9977 PyObject * obj1 = 0 ;
9978 char * kwnames[] = {
9979 (char *) "self",(char *) "n", NULL
9980 };
9981
9982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
9983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9984 if (!SWIG_IsOK(res1)) {
9985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9986 }
9987 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9988 ecode2 = SWIG_AsVal_int(obj1, &val2);
9989 if (!SWIG_IsOK(ecode2)) {
9990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
9991 }
9992 arg2 = static_cast< int >(val2);
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 (arg1)->SetCol(arg2);
9996 wxPyEndAllowThreads(__tstate);
9997 if (PyErr_Occurred()) SWIG_fail;
9998 }
9999 resultobj = SWIG_Py_Void();
10000 return resultobj;
10001 fail:
10002 return NULL;
10003 }
10004
10005
10006 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10007 PyObject *resultobj = 0;
10008 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10009 int arg2 ;
10010 int arg3 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 int val2 ;
10014 int ecode2 = 0 ;
10015 int val3 ;
10016 int ecode3 = 0 ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 PyObject * obj2 = 0 ;
10020 char * kwnames[] = {
10021 (char *) "self",(char *) "row",(char *) "col", NULL
10022 };
10023
10024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10026 if (!SWIG_IsOK(res1)) {
10027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10028 }
10029 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10030 ecode2 = SWIG_AsVal_int(obj1, &val2);
10031 if (!SWIG_IsOK(ecode2)) {
10032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10033 }
10034 arg2 = static_cast< int >(val2);
10035 ecode3 = SWIG_AsVal_int(obj2, &val3);
10036 if (!SWIG_IsOK(ecode3)) {
10037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10038 }
10039 arg3 = static_cast< int >(val3);
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 (arg1)->Set(arg2,arg3);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_Py_Void();
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10056 wxGridCellCoords *arg2 = 0 ;
10057 bool result;
10058 void *argp1 = 0 ;
10059 int res1 = 0 ;
10060 wxGridCellCoords temp2 ;
10061 PyObject * obj0 = 0 ;
10062 PyObject * obj1 = 0 ;
10063 char * kwnames[] = {
10064 (char *) "self",(char *) "other", NULL
10065 };
10066
10067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10069 if (!SWIG_IsOK(res1)) {
10070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10071 }
10072 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10073 {
10074 arg2 = &temp2;
10075 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (bool)((wxGridCellCoords const *)arg1)->operator ==((wxGridCellCoords const &)*arg2);
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10085 }
10086 return resultobj;
10087 fail:
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10093 PyObject *resultobj = 0;
10094 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10095 wxGridCellCoords *arg2 = 0 ;
10096 bool result;
10097 void *argp1 = 0 ;
10098 int res1 = 0 ;
10099 wxGridCellCoords temp2 ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 char * kwnames[] = {
10103 (char *) "self",(char *) "other", NULL
10104 };
10105
10106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10108 if (!SWIG_IsOK(res1)) {
10109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10110 }
10111 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10112 {
10113 arg2 = &temp2;
10114 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
10115 }
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 result = (bool)((wxGridCellCoords const *)arg1)->operator !=((wxGridCellCoords const &)*arg2);
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 {
10123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10124 }
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10132 PyObject *resultobj = 0;
10133 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10134 PyObject *result = 0 ;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 PyObject *swig_obj[1] ;
10138
10139 if (!args) SWIG_fail;
10140 swig_obj[0] = args;
10141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10144 }
10145 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10146 {
10147 PyThreadState* __tstate = wxPyBeginAllowThreads();
10148 result = (PyObject *)wxGridCellCoords_Get(arg1);
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 resultobj = result;
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 PyObject *obj;
10161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10162 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10163 return SWIG_Py_Void();
10164 }
10165
10166 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167 return SWIG_Python_InitShadowInstance(args);
10168 }
10169
10170 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj = 0;
10172 wxWindow *arg1 = (wxWindow *) 0 ;
10173 int arg2 = (int) -1 ;
10174 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10175 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10176 wxSize const &arg4_defvalue = wxDefaultSize ;
10177 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10178 long arg5 = (long) wxWANTS_CHARS ;
10179 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10180 wxString *arg6 = (wxString *) &arg6_defvalue ;
10181 wxGrid *result = 0 ;
10182 void *argp1 = 0 ;
10183 int res1 = 0 ;
10184 int val2 ;
10185 int ecode2 = 0 ;
10186 wxPoint temp3 ;
10187 wxSize temp4 ;
10188 long val5 ;
10189 int ecode5 = 0 ;
10190 bool temp6 = false ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 PyObject * obj2 = 0 ;
10194 PyObject * obj3 = 0 ;
10195 PyObject * obj4 = 0 ;
10196 PyObject * obj5 = 0 ;
10197 char * kwnames[] = {
10198 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10199 };
10200
10201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10203 if (!SWIG_IsOK(res1)) {
10204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10205 }
10206 arg1 = reinterpret_cast< wxWindow * >(argp1);
10207 if (obj1) {
10208 ecode2 = SWIG_AsVal_int(obj1, &val2);
10209 if (!SWIG_IsOK(ecode2)) {
10210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10211 }
10212 arg2 = static_cast< int >(val2);
10213 }
10214 if (obj2) {
10215 {
10216 arg3 = &temp3;
10217 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10218 }
10219 }
10220 if (obj3) {
10221 {
10222 arg4 = &temp4;
10223 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10224 }
10225 }
10226 if (obj4) {
10227 ecode5 = SWIG_AsVal_long(obj4, &val5);
10228 if (!SWIG_IsOK(ecode5)) {
10229 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10230 }
10231 arg5 = static_cast< long >(val5);
10232 }
10233 if (obj5) {
10234 {
10235 arg6 = wxString_in_helper(obj5);
10236 if (arg6 == NULL) SWIG_fail;
10237 temp6 = true;
10238 }
10239 }
10240 {
10241 if (!wxPyCheckForApp()) SWIG_fail;
10242 PyThreadState* __tstate = wxPyBeginAllowThreads();
10243 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10244 wxPyEndAllowThreads(__tstate);
10245 if (PyErr_Occurred()) SWIG_fail;
10246 }
10247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10248 {
10249 if (temp6)
10250 delete arg6;
10251 }
10252 return resultobj;
10253 fail:
10254 {
10255 if (temp6)
10256 delete arg6;
10257 }
10258 return NULL;
10259 }
10260
10261
10262 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10263 PyObject *resultobj = 0;
10264 wxGrid *result = 0 ;
10265
10266 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10267 {
10268 if (!wxPyCheckForApp()) SWIG_fail;
10269 PyThreadState* __tstate = wxPyBeginAllowThreads();
10270 result = (wxGrid *)new wxGrid();
10271 wxPyEndAllowThreads(__tstate);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10275 return resultobj;
10276 fail:
10277 return NULL;
10278 }
10279
10280
10281 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj = 0;
10283 wxGrid *arg1 = (wxGrid *) 0 ;
10284 wxWindow *arg2 = (wxWindow *) 0 ;
10285 int arg3 = (int) -1 ;
10286 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10287 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10288 wxSize const &arg5_defvalue = wxDefaultSize ;
10289 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10290 long arg6 = (long) wxWANTS_CHARS ;
10291 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10292 wxString *arg7 = (wxString *) &arg7_defvalue ;
10293 bool result;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 void *argp2 = 0 ;
10297 int res2 = 0 ;
10298 int val3 ;
10299 int ecode3 = 0 ;
10300 wxPoint temp4 ;
10301 wxSize temp5 ;
10302 long val6 ;
10303 int ecode6 = 0 ;
10304 bool temp7 = false ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 PyObject * obj2 = 0 ;
10308 PyObject * obj3 = 0 ;
10309 PyObject * obj4 = 0 ;
10310 PyObject * obj5 = 0 ;
10311 PyObject * obj6 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10320 }
10321 arg1 = reinterpret_cast< wxGrid * >(argp1);
10322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10323 if (!SWIG_IsOK(res2)) {
10324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10325 }
10326 arg2 = reinterpret_cast< wxWindow * >(argp2);
10327 if (obj2) {
10328 ecode3 = SWIG_AsVal_int(obj2, &val3);
10329 if (!SWIG_IsOK(ecode3)) {
10330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10331 }
10332 arg3 = static_cast< int >(val3);
10333 }
10334 if (obj3) {
10335 {
10336 arg4 = &temp4;
10337 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10338 }
10339 }
10340 if (obj4) {
10341 {
10342 arg5 = &temp5;
10343 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10344 }
10345 }
10346 if (obj5) {
10347 ecode6 = SWIG_AsVal_long(obj5, &val6);
10348 if (!SWIG_IsOK(ecode6)) {
10349 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10350 }
10351 arg6 = static_cast< long >(val6);
10352 }
10353 if (obj6) {
10354 {
10355 arg7 = wxString_in_helper(obj6);
10356 if (arg7 == NULL) SWIG_fail;
10357 temp7 = true;
10358 }
10359 }
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10368 }
10369 {
10370 if (temp7)
10371 delete arg7;
10372 }
10373 return resultobj;
10374 fail:
10375 {
10376 if (temp7)
10377 delete arg7;
10378 }
10379 return NULL;
10380 }
10381
10382
10383 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj = 0;
10385 wxGrid *arg1 = (wxGrid *) 0 ;
10386 int arg2 ;
10387 int arg3 ;
10388 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10389 bool result;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 int val2 ;
10393 int ecode2 = 0 ;
10394 int val3 ;
10395 int ecode3 = 0 ;
10396 int val4 ;
10397 int ecode4 = 0 ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 PyObject * obj2 = 0 ;
10401 PyObject * obj3 = 0 ;
10402 char * kwnames[] = {
10403 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10404 };
10405
10406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10408 if (!SWIG_IsOK(res1)) {
10409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10410 }
10411 arg1 = reinterpret_cast< wxGrid * >(argp1);
10412 ecode2 = SWIG_AsVal_int(obj1, &val2);
10413 if (!SWIG_IsOK(ecode2)) {
10414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10415 }
10416 arg2 = static_cast< int >(val2);
10417 ecode3 = SWIG_AsVal_int(obj2, &val3);
10418 if (!SWIG_IsOK(ecode3)) {
10419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10420 }
10421 arg3 = static_cast< int >(val3);
10422 if (obj3) {
10423 ecode4 = SWIG_AsVal_int(obj3, &val4);
10424 if (!SWIG_IsOK(ecode4)) {
10425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10426 }
10427 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10428 }
10429 {
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10432 wxPyEndAllowThreads(__tstate);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 {
10436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10437 }
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10445 PyObject *resultobj = 0;
10446 wxGrid *arg1 = (wxGrid *) 0 ;
10447 WXGRIDSELECTIONMODES arg2 ;
10448 void *argp1 = 0 ;
10449 int res1 = 0 ;
10450 int val2 ;
10451 int ecode2 = 0 ;
10452 PyObject * obj0 = 0 ;
10453 PyObject * obj1 = 0 ;
10454 char * kwnames[] = {
10455 (char *) "self",(char *) "selmode", NULL
10456 };
10457
10458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10460 if (!SWIG_IsOK(res1)) {
10461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10462 }
10463 arg1 = reinterpret_cast< wxGrid * >(argp1);
10464 ecode2 = SWIG_AsVal_int(obj1, &val2);
10465 if (!SWIG_IsOK(ecode2)) {
10466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10467 }
10468 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 (arg1)->SetSelectionMode(arg2);
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 resultobj = SWIG_Py_Void();
10476 return resultobj;
10477 fail:
10478 return NULL;
10479 }
10480
10481
10482 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10483 PyObject *resultobj = 0;
10484 wxGrid *arg1 = (wxGrid *) 0 ;
10485 WXGRIDSELECTIONMODES result;
10486 void *argp1 = 0 ;
10487 int res1 = 0 ;
10488 PyObject *swig_obj[1] ;
10489
10490 if (!args) SWIG_fail;
10491 swig_obj[0] = args;
10492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10493 if (!SWIG_IsOK(res1)) {
10494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10495 }
10496 arg1 = reinterpret_cast< wxGrid * >(argp1);
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10500 wxPyEndAllowThreads(__tstate);
10501 if (PyErr_Occurred()) SWIG_fail;
10502 }
10503 resultobj = SWIG_From_int(static_cast< int >(result));
10504 return resultobj;
10505 fail:
10506 return NULL;
10507 }
10508
10509
10510 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10511 PyObject *resultobj = 0;
10512 wxGrid *arg1 = (wxGrid *) 0 ;
10513 int result;
10514 void *argp1 = 0 ;
10515 int res1 = 0 ;
10516 PyObject *swig_obj[1] ;
10517
10518 if (!args) SWIG_fail;
10519 swig_obj[0] = args;
10520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10521 if (!SWIG_IsOK(res1)) {
10522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10523 }
10524 arg1 = reinterpret_cast< wxGrid * >(argp1);
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (int)(arg1)->GetNumberRows();
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 resultobj = SWIG_From_int(static_cast< int >(result));
10532 return resultobj;
10533 fail:
10534 return NULL;
10535 }
10536
10537
10538 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10539 PyObject *resultobj = 0;
10540 wxGrid *arg1 = (wxGrid *) 0 ;
10541 int result;
10542 void *argp1 = 0 ;
10543 int res1 = 0 ;
10544 PyObject *swig_obj[1] ;
10545
10546 if (!args) SWIG_fail;
10547 swig_obj[0] = args;
10548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10549 if (!SWIG_IsOK(res1)) {
10550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10551 }
10552 arg1 = reinterpret_cast< wxGrid * >(argp1);
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (int)(arg1)->GetNumberCols();
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 resultobj = SWIG_From_int(static_cast< int >(result));
10560 return resultobj;
10561 fail:
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxGrid *arg1 = (wxGrid *) 0 ;
10569 wxGridTableMessage *arg2 = 0 ;
10570 bool result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 void *argp2 = 0 ;
10574 int res2 = 0 ;
10575 PyObject * obj0 = 0 ;
10576 PyObject * obj1 = 0 ;
10577 char * kwnames[] = {
10578 (char *) "self",(char *)"arg2", NULL
10579 };
10580
10581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10585 }
10586 arg1 = reinterpret_cast< wxGrid * >(argp1);
10587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10588 if (!SWIG_IsOK(res2)) {
10589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10590 }
10591 if (!argp2) {
10592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10593 }
10594 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10595 {
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 {
10602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10611 PyObject *resultobj = 0;
10612 wxGrid *arg1 = (wxGrid *) 0 ;
10613 wxGridTableBase *result = 0 ;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 PyObject *swig_obj[1] ;
10617
10618 if (!args) SWIG_fail;
10619 swig_obj[0] = args;
10620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10623 }
10624 arg1 = reinterpret_cast< wxGrid * >(argp1);
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 {
10632 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10633 }
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10641 PyObject *resultobj = 0;
10642 wxGrid *arg1 = (wxGrid *) 0 ;
10643 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10644 bool arg3 = (bool) false ;
10645 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10646 bool result;
10647 void *argp1 = 0 ;
10648 int res1 = 0 ;
10649 void *argp2 = 0 ;
10650 int res2 = 0 ;
10651 bool val3 ;
10652 int ecode3 = 0 ;
10653 int val4 ;
10654 int ecode4 = 0 ;
10655 PyObject * obj0 = 0 ;
10656 PyObject * obj1 = 0 ;
10657 PyObject * obj2 = 0 ;
10658 PyObject * obj3 = 0 ;
10659 char * kwnames[] = {
10660 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10661 };
10662
10663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10665 if (!SWIG_IsOK(res1)) {
10666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10667 }
10668 arg1 = reinterpret_cast< wxGrid * >(argp1);
10669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
10670 if (!SWIG_IsOK(res2)) {
10671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10672 }
10673 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
10674 if (obj2) {
10675 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10676 if (!SWIG_IsOK(ecode3)) {
10677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10678 }
10679 arg3 = static_cast< bool >(val3);
10680 }
10681 if (obj3) {
10682 ecode4 = SWIG_AsVal_int(obj3, &val4);
10683 if (!SWIG_IsOK(ecode4)) {
10684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10685 }
10686 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10687 }
10688 {
10689 PyThreadState* __tstate = wxPyBeginAllowThreads();
10690 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 {
10695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10696 }
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704 PyObject *resultobj = 0;
10705 wxGrid *arg1 = (wxGrid *) 0 ;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 PyObject *swig_obj[1] ;
10709
10710 if (!args) SWIG_fail;
10711 swig_obj[0] = args;
10712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10713 if (!SWIG_IsOK(res1)) {
10714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10715 }
10716 arg1 = reinterpret_cast< wxGrid * >(argp1);
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 (arg1)->ClearGrid();
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 resultobj = SWIG_Py_Void();
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj = 0;
10732 wxGrid *arg1 = (wxGrid *) 0 ;
10733 int arg2 = (int) 0 ;
10734 int arg3 = (int) 1 ;
10735 bool arg4 = (bool) true ;
10736 bool result;
10737 void *argp1 = 0 ;
10738 int res1 = 0 ;
10739 int val2 ;
10740 int ecode2 = 0 ;
10741 int val3 ;
10742 int ecode3 = 0 ;
10743 bool val4 ;
10744 int ecode4 = 0 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 PyObject * obj2 = 0 ;
10748 PyObject * obj3 = 0 ;
10749 char * kwnames[] = {
10750 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10751 };
10752
10753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10755 if (!SWIG_IsOK(res1)) {
10756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10757 }
10758 arg1 = reinterpret_cast< wxGrid * >(argp1);
10759 if (obj1) {
10760 ecode2 = SWIG_AsVal_int(obj1, &val2);
10761 if (!SWIG_IsOK(ecode2)) {
10762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10763 }
10764 arg2 = static_cast< int >(val2);
10765 }
10766 if (obj2) {
10767 ecode3 = SWIG_AsVal_int(obj2, &val3);
10768 if (!SWIG_IsOK(ecode3)) {
10769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10770 }
10771 arg3 = static_cast< int >(val3);
10772 }
10773 if (obj3) {
10774 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10775 if (!SWIG_IsOK(ecode4)) {
10776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10777 }
10778 arg4 = static_cast< bool >(val4);
10779 }
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 {
10787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10788 }
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxGrid *arg1 = (wxGrid *) 0 ;
10798 int arg2 = (int) 1 ;
10799 bool arg3 = (bool) true ;
10800 bool result;
10801 void *argp1 = 0 ;
10802 int res1 = 0 ;
10803 int val2 ;
10804 int ecode2 = 0 ;
10805 bool val3 ;
10806 int ecode3 = 0 ;
10807 PyObject * obj0 = 0 ;
10808 PyObject * obj1 = 0 ;
10809 PyObject * obj2 = 0 ;
10810 char * kwnames[] = {
10811 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10812 };
10813
10814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10816 if (!SWIG_IsOK(res1)) {
10817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10818 }
10819 arg1 = reinterpret_cast< wxGrid * >(argp1);
10820 if (obj1) {
10821 ecode2 = SWIG_AsVal_int(obj1, &val2);
10822 if (!SWIG_IsOK(ecode2)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10824 }
10825 arg2 = static_cast< int >(val2);
10826 }
10827 if (obj2) {
10828 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10829 if (!SWIG_IsOK(ecode3)) {
10830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10831 }
10832 arg3 = static_cast< bool >(val3);
10833 }
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (bool)(arg1)->AppendRows(arg2,arg3);
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 {
10841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10842 }
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10850 PyObject *resultobj = 0;
10851 wxGrid *arg1 = (wxGrid *) 0 ;
10852 int arg2 = (int) 0 ;
10853 int arg3 = (int) 1 ;
10854 bool arg4 = (bool) true ;
10855 bool result;
10856 void *argp1 = 0 ;
10857 int res1 = 0 ;
10858 int val2 ;
10859 int ecode2 = 0 ;
10860 int val3 ;
10861 int ecode3 = 0 ;
10862 bool val4 ;
10863 int ecode4 = 0 ;
10864 PyObject * obj0 = 0 ;
10865 PyObject * obj1 = 0 ;
10866 PyObject * obj2 = 0 ;
10867 PyObject * obj3 = 0 ;
10868 char * kwnames[] = {
10869 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10870 };
10871
10872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10874 if (!SWIG_IsOK(res1)) {
10875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10876 }
10877 arg1 = reinterpret_cast< wxGrid * >(argp1);
10878 if (obj1) {
10879 ecode2 = SWIG_AsVal_int(obj1, &val2);
10880 if (!SWIG_IsOK(ecode2)) {
10881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10882 }
10883 arg2 = static_cast< int >(val2);
10884 }
10885 if (obj2) {
10886 ecode3 = SWIG_AsVal_int(obj2, &val3);
10887 if (!SWIG_IsOK(ecode3)) {
10888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10889 }
10890 arg3 = static_cast< int >(val3);
10891 }
10892 if (obj3) {
10893 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10894 if (!SWIG_IsOK(ecode4)) {
10895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10896 }
10897 arg4 = static_cast< bool >(val4);
10898 }
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10902 wxPyEndAllowThreads(__tstate);
10903 if (PyErr_Occurred()) SWIG_fail;
10904 }
10905 {
10906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10907 }
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxGrid *arg1 = (wxGrid *) 0 ;
10917 int arg2 = (int) 0 ;
10918 int arg3 = (int) 1 ;
10919 bool arg4 = (bool) true ;
10920 bool result;
10921 void *argp1 = 0 ;
10922 int res1 = 0 ;
10923 int val2 ;
10924 int ecode2 = 0 ;
10925 int val3 ;
10926 int ecode3 = 0 ;
10927 bool val4 ;
10928 int ecode4 = 0 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 PyObject * obj2 = 0 ;
10932 PyObject * obj3 = 0 ;
10933 char * kwnames[] = {
10934 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10935 };
10936
10937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10939 if (!SWIG_IsOK(res1)) {
10940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10941 }
10942 arg1 = reinterpret_cast< wxGrid * >(argp1);
10943 if (obj1) {
10944 ecode2 = SWIG_AsVal_int(obj1, &val2);
10945 if (!SWIG_IsOK(ecode2)) {
10946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10947 }
10948 arg2 = static_cast< int >(val2);
10949 }
10950 if (obj2) {
10951 ecode3 = SWIG_AsVal_int(obj2, &val3);
10952 if (!SWIG_IsOK(ecode3)) {
10953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10954 }
10955 arg3 = static_cast< int >(val3);
10956 }
10957 if (obj3) {
10958 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10959 if (!SWIG_IsOK(ecode4)) {
10960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10961 }
10962 arg4 = static_cast< bool >(val4);
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10972 }
10973 return resultobj;
10974 fail:
10975 return NULL;
10976 }
10977
10978
10979 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj = 0;
10981 wxGrid *arg1 = (wxGrid *) 0 ;
10982 int arg2 = (int) 1 ;
10983 bool arg3 = (bool) true ;
10984 bool result;
10985 void *argp1 = 0 ;
10986 int res1 = 0 ;
10987 int val2 ;
10988 int ecode2 = 0 ;
10989 bool val3 ;
10990 int ecode3 = 0 ;
10991 PyObject * obj0 = 0 ;
10992 PyObject * obj1 = 0 ;
10993 PyObject * obj2 = 0 ;
10994 char * kwnames[] = {
10995 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
10996 };
10997
10998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11000 if (!SWIG_IsOK(res1)) {
11001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11002 }
11003 arg1 = reinterpret_cast< wxGrid * >(argp1);
11004 if (obj1) {
11005 ecode2 = SWIG_AsVal_int(obj1, &val2);
11006 if (!SWIG_IsOK(ecode2)) {
11007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11008 }
11009 arg2 = static_cast< int >(val2);
11010 }
11011 if (obj2) {
11012 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11013 if (!SWIG_IsOK(ecode3)) {
11014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11015 }
11016 arg3 = static_cast< bool >(val3);
11017 }
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (bool)(arg1)->AppendCols(arg2,arg3);
11021 wxPyEndAllowThreads(__tstate);
11022 if (PyErr_Occurred()) SWIG_fail;
11023 }
11024 {
11025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11026 }
11027 return resultobj;
11028 fail:
11029 return NULL;
11030 }
11031
11032
11033 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj = 0;
11035 wxGrid *arg1 = (wxGrid *) 0 ;
11036 int arg2 = (int) 0 ;
11037 int arg3 = (int) 1 ;
11038 bool arg4 = (bool) true ;
11039 bool result;
11040 void *argp1 = 0 ;
11041 int res1 = 0 ;
11042 int val2 ;
11043 int ecode2 = 0 ;
11044 int val3 ;
11045 int ecode3 = 0 ;
11046 bool val4 ;
11047 int ecode4 = 0 ;
11048 PyObject * obj0 = 0 ;
11049 PyObject * obj1 = 0 ;
11050 PyObject * obj2 = 0 ;
11051 PyObject * obj3 = 0 ;
11052 char * kwnames[] = {
11053 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11054 };
11055
11056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11058 if (!SWIG_IsOK(res1)) {
11059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11060 }
11061 arg1 = reinterpret_cast< wxGrid * >(argp1);
11062 if (obj1) {
11063 ecode2 = SWIG_AsVal_int(obj1, &val2);
11064 if (!SWIG_IsOK(ecode2)) {
11065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11066 }
11067 arg2 = static_cast< int >(val2);
11068 }
11069 if (obj2) {
11070 ecode3 = SWIG_AsVal_int(obj2, &val3);
11071 if (!SWIG_IsOK(ecode3)) {
11072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11073 }
11074 arg3 = static_cast< int >(val3);
11075 }
11076 if (obj3) {
11077 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11078 if (!SWIG_IsOK(ecode4)) {
11079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11080 }
11081 arg4 = static_cast< bool >(val4);
11082 }
11083 {
11084 PyThreadState* __tstate = wxPyBeginAllowThreads();
11085 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11086 wxPyEndAllowThreads(__tstate);
11087 if (PyErr_Occurred()) SWIG_fail;
11088 }
11089 {
11090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11091 }
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj = 0;
11100 wxGrid *arg1 = (wxGrid *) 0 ;
11101 wxDC *arg2 = 0 ;
11102 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11103 void *argp1 = 0 ;
11104 int res1 = 0 ;
11105 void *argp2 = 0 ;
11106 int res2 = 0 ;
11107 void *argp3 = 0 ;
11108 int res3 = 0 ;
11109 PyObject * obj0 = 0 ;
11110 PyObject * obj1 = 0 ;
11111 PyObject * obj2 = 0 ;
11112 char * kwnames[] = {
11113 (char *) "self",(char *) "dc",(char *) "attr", NULL
11114 };
11115
11116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11118 if (!SWIG_IsOK(res1)) {
11119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11120 }
11121 arg1 = reinterpret_cast< wxGrid * >(argp1);
11122 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11123 if (!SWIG_IsOK(res2)) {
11124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11125 }
11126 if (!argp2) {
11127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11128 }
11129 arg2 = reinterpret_cast< wxDC * >(argp2);
11130 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11131 if (!SWIG_IsOK(res3)) {
11132 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11133 }
11134 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 resultobj = SWIG_Py_Void();
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 wxGrid *arg1 = (wxGrid *) 0 ;
11151 wxDC *arg2 = 0 ;
11152 wxString *arg3 = 0 ;
11153 wxRect *arg4 = 0 ;
11154 int arg5 = (int) wxLEFT ;
11155 int arg6 = (int) wxTOP ;
11156 int arg7 = (int) wxHORIZONTAL ;
11157 void *argp1 = 0 ;
11158 int res1 = 0 ;
11159 void *argp2 = 0 ;
11160 int res2 = 0 ;
11161 bool temp3 = false ;
11162 wxRect temp4 ;
11163 int val5 ;
11164 int ecode5 = 0 ;
11165 int val6 ;
11166 int ecode6 = 0 ;
11167 int val7 ;
11168 int ecode7 = 0 ;
11169 PyObject * obj0 = 0 ;
11170 PyObject * obj1 = 0 ;
11171 PyObject * obj2 = 0 ;
11172 PyObject * obj3 = 0 ;
11173 PyObject * obj4 = 0 ;
11174 PyObject * obj5 = 0 ;
11175 PyObject * obj6 = 0 ;
11176 char * kwnames[] = {
11177 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11178 };
11179
11180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11184 }
11185 arg1 = reinterpret_cast< wxGrid * >(argp1);
11186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11187 if (!SWIG_IsOK(res2)) {
11188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11189 }
11190 if (!argp2) {
11191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11192 }
11193 arg2 = reinterpret_cast< wxDC * >(argp2);
11194 {
11195 arg3 = wxString_in_helper(obj2);
11196 if (arg3 == NULL) SWIG_fail;
11197 temp3 = true;
11198 }
11199 {
11200 arg4 = &temp4;
11201 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11202 }
11203 if (obj4) {
11204 ecode5 = SWIG_AsVal_int(obj4, &val5);
11205 if (!SWIG_IsOK(ecode5)) {
11206 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11207 }
11208 arg5 = static_cast< int >(val5);
11209 }
11210 if (obj5) {
11211 ecode6 = SWIG_AsVal_int(obj5, &val6);
11212 if (!SWIG_IsOK(ecode6)) {
11213 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11214 }
11215 arg6 = static_cast< int >(val6);
11216 }
11217 if (obj6) {
11218 ecode7 = SWIG_AsVal_int(obj6, &val7);
11219 if (!SWIG_IsOK(ecode7)) {
11220 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11221 }
11222 arg7 = static_cast< int >(val7);
11223 }
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 resultobj = SWIG_Py_Void();
11231 {
11232 if (temp3)
11233 delete arg3;
11234 }
11235 return resultobj;
11236 fail:
11237 {
11238 if (temp3)
11239 delete arg3;
11240 }
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11246 PyObject *resultobj = 0;
11247 wxGrid *arg1 = (wxGrid *) 0 ;
11248 wxDC *arg2 = 0 ;
11249 wxArrayString *arg3 = 0 ;
11250 long *arg4 = (long *) 0 ;
11251 long *arg5 = (long *) 0 ;
11252 void *argp1 = 0 ;
11253 int res1 = 0 ;
11254 void *argp2 = 0 ;
11255 int res2 = 0 ;
11256 bool temp3 = false ;
11257 long temp4 ;
11258 int res4 = SWIG_TMPOBJ ;
11259 long temp5 ;
11260 int res5 = SWIG_TMPOBJ ;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "self",(char *) "dc",(char *) "lines", NULL
11266 };
11267
11268 arg4 = &temp4;
11269 arg5 = &temp5;
11270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11272 if (!SWIG_IsOK(res1)) {
11273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11274 }
11275 arg1 = reinterpret_cast< wxGrid * >(argp1);
11276 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11277 if (!SWIG_IsOK(res2)) {
11278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11279 }
11280 if (!argp2) {
11281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11282 }
11283 arg2 = reinterpret_cast< wxDC * >(argp2);
11284 {
11285 if (! PySequence_Check(obj2)) {
11286 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11287 SWIG_fail;
11288 }
11289 arg3 = new wxArrayString;
11290 temp3 = true;
11291 int i, len=PySequence_Length(obj2);
11292 for (i=0; i<len; i++) {
11293 PyObject* item = PySequence_GetItem(obj2, i);
11294 wxString* s = wxString_in_helper(item);
11295 if (PyErr_Occurred()) SWIG_fail;
11296 arg3->Add(*s);
11297 delete s;
11298 Py_DECREF(item);
11299 }
11300 }
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 resultobj = SWIG_Py_Void();
11308 if (SWIG_IsTmpObj(res4)) {
11309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11310 } else {
11311 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11313 }
11314 if (SWIG_IsTmpObj(res5)) {
11315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11316 } else {
11317 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11319 }
11320 {
11321 if (temp3) delete arg3;
11322 }
11323 return resultobj;
11324 fail:
11325 {
11326 if (temp3) delete arg3;
11327 }
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11333 PyObject *resultobj = 0;
11334 wxGrid *arg1 = (wxGrid *) 0 ;
11335 void *argp1 = 0 ;
11336 int res1 = 0 ;
11337 PyObject *swig_obj[1] ;
11338
11339 if (!args) SWIG_fail;
11340 swig_obj[0] = args;
11341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11342 if (!SWIG_IsOK(res1)) {
11343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11344 }
11345 arg1 = reinterpret_cast< wxGrid * >(argp1);
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 (arg1)->BeginBatch();
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 resultobj = SWIG_Py_Void();
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11360 PyObject *resultobj = 0;
11361 wxGrid *arg1 = (wxGrid *) 0 ;
11362 void *argp1 = 0 ;
11363 int res1 = 0 ;
11364 PyObject *swig_obj[1] ;
11365
11366 if (!args) SWIG_fail;
11367 swig_obj[0] = args;
11368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11369 if (!SWIG_IsOK(res1)) {
11370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11371 }
11372 arg1 = reinterpret_cast< wxGrid * >(argp1);
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 (arg1)->EndBatch();
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = SWIG_Py_Void();
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 wxGrid *arg1 = (wxGrid *) 0 ;
11389 int result;
11390 void *argp1 = 0 ;
11391 int res1 = 0 ;
11392 PyObject *swig_obj[1] ;
11393
11394 if (!args) SWIG_fail;
11395 swig_obj[0] = args;
11396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11399 }
11400 arg1 = reinterpret_cast< wxGrid * >(argp1);
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (int)(arg1)->GetBatchCount();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 resultobj = SWIG_From_int(static_cast< int >(result));
11408 return resultobj;
11409 fail:
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11415 PyObject *resultobj = 0;
11416 wxGrid *arg1 = (wxGrid *) 0 ;
11417 void *argp1 = 0 ;
11418 int res1 = 0 ;
11419 PyObject *swig_obj[1] ;
11420
11421 if (!args) SWIG_fail;
11422 swig_obj[0] = args;
11423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11426 }
11427 arg1 = reinterpret_cast< wxGrid * >(argp1);
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 (arg1)->ForceRefresh();
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_Py_Void();
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11442 PyObject *resultobj = 0;
11443 wxGrid *arg1 = (wxGrid *) 0 ;
11444 bool result;
11445 void *argp1 = 0 ;
11446 int res1 = 0 ;
11447 PyObject *swig_obj[1] ;
11448
11449 if (!args) SWIG_fail;
11450 swig_obj[0] = args;
11451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11452 if (!SWIG_IsOK(res1)) {
11453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11454 }
11455 arg1 = reinterpret_cast< wxGrid * >(argp1);
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (bool)(arg1)->IsEditable();
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 {
11463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11464 }
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxGrid *arg1 = (wxGrid *) 0 ;
11474 bool arg2 ;
11475 void *argp1 = 0 ;
11476 int res1 = 0 ;
11477 bool val2 ;
11478 int ecode2 = 0 ;
11479 PyObject * obj0 = 0 ;
11480 PyObject * obj1 = 0 ;
11481 char * kwnames[] = {
11482 (char *) "self",(char *) "edit", NULL
11483 };
11484
11485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11487 if (!SWIG_IsOK(res1)) {
11488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11489 }
11490 arg1 = reinterpret_cast< wxGrid * >(argp1);
11491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11492 if (!SWIG_IsOK(ecode2)) {
11493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11494 }
11495 arg2 = static_cast< bool >(val2);
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 (arg1)->EnableEditing(arg2);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_Py_Void();
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11510 PyObject *resultobj = 0;
11511 wxGrid *arg1 = (wxGrid *) 0 ;
11512 bool arg2 = (bool) true ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 bool val2 ;
11516 int ecode2 = 0 ;
11517 PyObject * obj0 = 0 ;
11518 PyObject * obj1 = 0 ;
11519 char * kwnames[] = {
11520 (char *) "self",(char *) "enable", NULL
11521 };
11522
11523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11527 }
11528 arg1 = reinterpret_cast< wxGrid * >(argp1);
11529 if (obj1) {
11530 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11531 if (!SWIG_IsOK(ecode2)) {
11532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11533 }
11534 arg2 = static_cast< bool >(val2);
11535 }
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 (arg1)->EnableCellEditControl(arg2);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_Py_Void();
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11550 PyObject *resultobj = 0;
11551 wxGrid *arg1 = (wxGrid *) 0 ;
11552 void *argp1 = 0 ;
11553 int res1 = 0 ;
11554 PyObject *swig_obj[1] ;
11555
11556 if (!args) SWIG_fail;
11557 swig_obj[0] = args;
11558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11559 if (!SWIG_IsOK(res1)) {
11560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11561 }
11562 arg1 = reinterpret_cast< wxGrid * >(argp1);
11563 {
11564 PyThreadState* __tstate = wxPyBeginAllowThreads();
11565 (arg1)->DisableCellEditControl();
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 resultobj = SWIG_Py_Void();
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11577 PyObject *resultobj = 0;
11578 wxGrid *arg1 = (wxGrid *) 0 ;
11579 bool result;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 PyObject *swig_obj[1] ;
11583
11584 if (!args) SWIG_fail;
11585 swig_obj[0] = args;
11586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11587 if (!SWIG_IsOK(res1)) {
11588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11589 }
11590 arg1 = reinterpret_cast< wxGrid * >(argp1);
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 {
11598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11599 }
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 wxGrid *arg1 = (wxGrid *) 0 ;
11609 bool result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 PyObject *swig_obj[1] ;
11613
11614 if (!args) SWIG_fail;
11615 swig_obj[0] = args;
11616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11619 }
11620 arg1 = reinterpret_cast< wxGrid * >(argp1);
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11629 }
11630 return resultobj;
11631 fail:
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxGrid *arg1 = (wxGrid *) 0 ;
11639 bool result;
11640 void *argp1 = 0 ;
11641 int res1 = 0 ;
11642 PyObject *swig_obj[1] ;
11643
11644 if (!args) SWIG_fail;
11645 swig_obj[0] = args;
11646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11649 }
11650 arg1 = reinterpret_cast< wxGrid * >(argp1);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11659 }
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *resultobj = 0;
11668 wxGrid *arg1 = (wxGrid *) 0 ;
11669 bool result;
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_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11679 }
11680 arg1 = reinterpret_cast< wxGrid * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 {
11688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11689 }
11690 return resultobj;
11691 fail:
11692 return NULL;
11693 }
11694
11695
11696 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11697 PyObject *resultobj = 0;
11698 wxGrid *arg1 = (wxGrid *) 0 ;
11699 void *argp1 = 0 ;
11700 int res1 = 0 ;
11701 PyObject *swig_obj[1] ;
11702
11703 if (!args) SWIG_fail;
11704 swig_obj[0] = args;
11705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11708 }
11709 arg1 = reinterpret_cast< wxGrid * >(argp1);
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 (arg1)->ShowCellEditControl();
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 resultobj = SWIG_Py_Void();
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxGrid *arg1 = (wxGrid *) 0 ;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11735 }
11736 arg1 = reinterpret_cast< wxGrid * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 (arg1)->HideCellEditControl();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_Py_Void();
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxGrid *arg1 = (wxGrid *) 0 ;
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_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11762 }
11763 arg1 = reinterpret_cast< wxGrid * >(argp1);
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 (arg1)->SaveEditControlValue();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 resultobj = SWIG_Py_Void();
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11778 PyObject *resultobj = 0;
11779 wxGrid *arg1 = (wxGrid *) 0 ;
11780 int arg2 ;
11781 int arg3 ;
11782 wxGridCellCoords result;
11783 void *argp1 = 0 ;
11784 int res1 = 0 ;
11785 int val2 ;
11786 int ecode2 = 0 ;
11787 int val3 ;
11788 int ecode3 = 0 ;
11789 PyObject * obj0 = 0 ;
11790 PyObject * obj1 = 0 ;
11791 PyObject * obj2 = 0 ;
11792 char * kwnames[] = {
11793 (char *) "self",(char *) "x",(char *) "y", NULL
11794 };
11795
11796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11798 if (!SWIG_IsOK(res1)) {
11799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11800 }
11801 arg1 = reinterpret_cast< wxGrid * >(argp1);
11802 ecode2 = SWIG_AsVal_int(obj1, &val2);
11803 if (!SWIG_IsOK(ecode2)) {
11804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11805 }
11806 arg2 = static_cast< int >(val2);
11807 ecode3 = SWIG_AsVal_int(obj2, &val3);
11808 if (!SWIG_IsOK(ecode3)) {
11809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11810 }
11811 arg3 = static_cast< int >(val3);
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = wxGrid_XYToCell(arg1,arg2,arg3);
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11819 return resultobj;
11820 fail:
11821 return NULL;
11822 }
11823
11824
11825 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11826 PyObject *resultobj = 0;
11827 wxGrid *arg1 = (wxGrid *) 0 ;
11828 int arg2 ;
11829 int result;
11830 void *argp1 = 0 ;
11831 int res1 = 0 ;
11832 int val2 ;
11833 int ecode2 = 0 ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 char * kwnames[] = {
11837 (char *) "self",(char *) "y", NULL
11838 };
11839
11840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11842 if (!SWIG_IsOK(res1)) {
11843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11844 }
11845 arg1 = reinterpret_cast< wxGrid * >(argp1);
11846 ecode2 = SWIG_AsVal_int(obj1, &val2);
11847 if (!SWIG_IsOK(ecode2)) {
11848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11849 }
11850 arg2 = static_cast< int >(val2);
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (int)(arg1)->YToRow(arg2);
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 resultobj = SWIG_From_int(static_cast< int >(result));
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj = 0;
11866 wxGrid *arg1 = (wxGrid *) 0 ;
11867 int arg2 ;
11868 int result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 int val2 ;
11872 int ecode2 = 0 ;
11873 PyObject * obj0 = 0 ;
11874 PyObject * obj1 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "self",(char *) "x", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) SWIG_fail;
11880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11881 if (!SWIG_IsOK(res1)) {
11882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11883 }
11884 arg1 = reinterpret_cast< wxGrid * >(argp1);
11885 ecode2 = SWIG_AsVal_int(obj1, &val2);
11886 if (!SWIG_IsOK(ecode2)) {
11887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11888 }
11889 arg2 = static_cast< int >(val2);
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (int)(arg1)->XToCol(arg2);
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 resultobj = SWIG_From_int(static_cast< int >(result));
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = 0;
11905 wxGrid *arg1 = (wxGrid *) 0 ;
11906 int arg2 ;
11907 int result;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 int val2 ;
11911 int ecode2 = 0 ;
11912 PyObject * obj0 = 0 ;
11913 PyObject * obj1 = 0 ;
11914 char * kwnames[] = {
11915 (char *) "self",(char *) "y", NULL
11916 };
11917
11918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11920 if (!SWIG_IsOK(res1)) {
11921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11922 }
11923 arg1 = reinterpret_cast< wxGrid * >(argp1);
11924 ecode2 = SWIG_AsVal_int(obj1, &val2);
11925 if (!SWIG_IsOK(ecode2)) {
11926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11927 }
11928 arg2 = static_cast< int >(val2);
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 result = (int)(arg1)->YToEdgeOfRow(arg2);
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 resultobj = SWIG_From_int(static_cast< int >(result));
11936 return resultobj;
11937 fail:
11938 return NULL;
11939 }
11940
11941
11942 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11943 PyObject *resultobj = 0;
11944 wxGrid *arg1 = (wxGrid *) 0 ;
11945 int arg2 ;
11946 int result;
11947 void *argp1 = 0 ;
11948 int res1 = 0 ;
11949 int val2 ;
11950 int ecode2 = 0 ;
11951 PyObject * obj0 = 0 ;
11952 PyObject * obj1 = 0 ;
11953 char * kwnames[] = {
11954 (char *) "self",(char *) "x", NULL
11955 };
11956
11957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
11958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11959 if (!SWIG_IsOK(res1)) {
11960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11961 }
11962 arg1 = reinterpret_cast< wxGrid * >(argp1);
11963 ecode2 = SWIG_AsVal_int(obj1, &val2);
11964 if (!SWIG_IsOK(ecode2)) {
11965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
11966 }
11967 arg2 = static_cast< int >(val2);
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 result = (int)(arg1)->XToEdgeOfCol(arg2);
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 resultobj = SWIG_From_int(static_cast< int >(result));
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj = 0;
11983 wxGrid *arg1 = (wxGrid *) 0 ;
11984 int arg2 ;
11985 int arg3 ;
11986 wxRect result;
11987 void *argp1 = 0 ;
11988 int res1 = 0 ;
11989 int val2 ;
11990 int ecode2 = 0 ;
11991 int val3 ;
11992 int ecode3 = 0 ;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 PyObject * obj2 = 0 ;
11996 char * kwnames[] = {
11997 (char *) "self",(char *) "row",(char *) "col", NULL
11998 };
11999
12000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12002 if (!SWIG_IsOK(res1)) {
12003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12004 }
12005 arg1 = reinterpret_cast< wxGrid * >(argp1);
12006 ecode2 = SWIG_AsVal_int(obj1, &val2);
12007 if (!SWIG_IsOK(ecode2)) {
12008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12009 }
12010 arg2 = static_cast< int >(val2);
12011 ecode3 = SWIG_AsVal_int(obj2, &val3);
12012 if (!SWIG_IsOK(ecode3)) {
12013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12014 }
12015 arg3 = static_cast< int >(val3);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (arg1)->CellToRect(arg2,arg3);
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12030 PyObject *resultobj = 0;
12031 wxGrid *arg1 = (wxGrid *) 0 ;
12032 int result;
12033 void *argp1 = 0 ;
12034 int res1 = 0 ;
12035 PyObject *swig_obj[1] ;
12036
12037 if (!args) SWIG_fail;
12038 swig_obj[0] = args;
12039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12040 if (!SWIG_IsOK(res1)) {
12041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12042 }
12043 arg1 = reinterpret_cast< wxGrid * >(argp1);
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (int)(arg1)->GetGridCursorRow();
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_From_int(static_cast< int >(result));
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12058 PyObject *resultobj = 0;
12059 wxGrid *arg1 = (wxGrid *) 0 ;
12060 int result;
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_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12070 }
12071 arg1 = reinterpret_cast< wxGrid * >(argp1);
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (int)(arg1)->GetGridCursorCol();
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_From_int(static_cast< int >(result));
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj = 0;
12087 wxGrid *arg1 = (wxGrid *) 0 ;
12088 int arg2 ;
12089 int arg3 ;
12090 bool arg4 = (bool) true ;
12091 bool result;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 int val2 ;
12095 int ecode2 = 0 ;
12096 int val3 ;
12097 int ecode3 = 0 ;
12098 bool val4 ;
12099 int ecode4 = 0 ;
12100 PyObject * obj0 = 0 ;
12101 PyObject * obj1 = 0 ;
12102 PyObject * obj2 = 0 ;
12103 PyObject * obj3 = 0 ;
12104 char * kwnames[] = {
12105 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12106 };
12107
12108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12110 if (!SWIG_IsOK(res1)) {
12111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12112 }
12113 arg1 = reinterpret_cast< wxGrid * >(argp1);
12114 ecode2 = SWIG_AsVal_int(obj1, &val2);
12115 if (!SWIG_IsOK(ecode2)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12117 }
12118 arg2 = static_cast< int >(val2);
12119 ecode3 = SWIG_AsVal_int(obj2, &val3);
12120 if (!SWIG_IsOK(ecode3)) {
12121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12122 }
12123 arg3 = static_cast< int >(val3);
12124 if (obj3) {
12125 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12126 if (!SWIG_IsOK(ecode4)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12128 }
12129 arg4 = static_cast< bool >(val4);
12130 }
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 {
12138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12139 }
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12147 PyObject *resultobj = 0;
12148 wxGrid *arg1 = (wxGrid *) 0 ;
12149 int arg2 ;
12150 int arg3 ;
12151 void *argp1 = 0 ;
12152 int res1 = 0 ;
12153 int val2 ;
12154 int ecode2 = 0 ;
12155 int val3 ;
12156 int ecode3 = 0 ;
12157 PyObject * obj0 = 0 ;
12158 PyObject * obj1 = 0 ;
12159 PyObject * obj2 = 0 ;
12160 char * kwnames[] = {
12161 (char *) "self",(char *) "row",(char *) "col", NULL
12162 };
12163
12164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12166 if (!SWIG_IsOK(res1)) {
12167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12168 }
12169 arg1 = reinterpret_cast< wxGrid * >(argp1);
12170 ecode2 = SWIG_AsVal_int(obj1, &val2);
12171 if (!SWIG_IsOK(ecode2)) {
12172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12173 }
12174 arg2 = static_cast< int >(val2);
12175 ecode3 = SWIG_AsVal_int(obj2, &val3);
12176 if (!SWIG_IsOK(ecode3)) {
12177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12178 }
12179 arg3 = static_cast< int >(val3);
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 (arg1)->MakeCellVisible(arg2,arg3);
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 resultobj = SWIG_Py_Void();
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj = 0;
12195 wxGrid *arg1 = (wxGrid *) 0 ;
12196 int arg2 ;
12197 int arg3 ;
12198 void *argp1 = 0 ;
12199 int res1 = 0 ;
12200 int val2 ;
12201 int ecode2 = 0 ;
12202 int val3 ;
12203 int ecode3 = 0 ;
12204 PyObject * obj0 = 0 ;
12205 PyObject * obj1 = 0 ;
12206 PyObject * obj2 = 0 ;
12207 char * kwnames[] = {
12208 (char *) "self",(char *) "row",(char *) "col", NULL
12209 };
12210
12211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12213 if (!SWIG_IsOK(res1)) {
12214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12215 }
12216 arg1 = reinterpret_cast< wxGrid * >(argp1);
12217 ecode2 = SWIG_AsVal_int(obj1, &val2);
12218 if (!SWIG_IsOK(ecode2)) {
12219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12220 }
12221 arg2 = static_cast< int >(val2);
12222 ecode3 = SWIG_AsVal_int(obj2, &val3);
12223 if (!SWIG_IsOK(ecode3)) {
12224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12225 }
12226 arg3 = static_cast< int >(val3);
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 (arg1)->SetGridCursor(arg2,arg3);
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = SWIG_Py_Void();
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 wxGrid *arg1 = (wxGrid *) 0 ;
12243 bool arg2 ;
12244 bool result;
12245 void *argp1 = 0 ;
12246 int res1 = 0 ;
12247 bool val2 ;
12248 int ecode2 = 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "expandSelection", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12259 }
12260 arg1 = reinterpret_cast< wxGrid * >(argp1);
12261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12262 if (!SWIG_IsOK(ecode2)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12264 }
12265 arg2 = static_cast< bool >(val2);
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (bool)(arg1)->MoveCursorUp(arg2);
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12274 }
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj = 0;
12283 wxGrid *arg1 = (wxGrid *) 0 ;
12284 bool arg2 ;
12285 bool result;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 bool val2 ;
12289 int ecode2 = 0 ;
12290 PyObject * obj0 = 0 ;
12291 PyObject * obj1 = 0 ;
12292 char * kwnames[] = {
12293 (char *) "self",(char *) "expandSelection", NULL
12294 };
12295
12296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12298 if (!SWIG_IsOK(res1)) {
12299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12300 }
12301 arg1 = reinterpret_cast< wxGrid * >(argp1);
12302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12303 if (!SWIG_IsOK(ecode2)) {
12304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12305 }
12306 arg2 = static_cast< bool >(val2);
12307 {
12308 PyThreadState* __tstate = wxPyBeginAllowThreads();
12309 result = (bool)(arg1)->MoveCursorDown(arg2);
12310 wxPyEndAllowThreads(__tstate);
12311 if (PyErr_Occurred()) SWIG_fail;
12312 }
12313 {
12314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12315 }
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 wxGrid *arg1 = (wxGrid *) 0 ;
12325 bool arg2 ;
12326 bool result;
12327 void *argp1 = 0 ;
12328 int res1 = 0 ;
12329 bool val2 ;
12330 int ecode2 = 0 ;
12331 PyObject * obj0 = 0 ;
12332 PyObject * obj1 = 0 ;
12333 char * kwnames[] = {
12334 (char *) "self",(char *) "expandSelection", NULL
12335 };
12336
12337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12341 }
12342 arg1 = reinterpret_cast< wxGrid * >(argp1);
12343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12344 if (!SWIG_IsOK(ecode2)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12346 }
12347 arg2 = static_cast< bool >(val2);
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 result = (bool)(arg1)->MoveCursorLeft(arg2);
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 {
12355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12356 }
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj = 0;
12365 wxGrid *arg1 = (wxGrid *) 0 ;
12366 bool arg2 ;
12367 bool result;
12368 void *argp1 = 0 ;
12369 int res1 = 0 ;
12370 bool val2 ;
12371 int ecode2 = 0 ;
12372 PyObject * obj0 = 0 ;
12373 PyObject * obj1 = 0 ;
12374 char * kwnames[] = {
12375 (char *) "self",(char *) "expandSelection", NULL
12376 };
12377
12378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12380 if (!SWIG_IsOK(res1)) {
12381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12382 }
12383 arg1 = reinterpret_cast< wxGrid * >(argp1);
12384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12385 if (!SWIG_IsOK(ecode2)) {
12386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12387 }
12388 arg2 = static_cast< bool >(val2);
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (bool)(arg1)->MoveCursorRight(arg2);
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12405 PyObject *resultobj = 0;
12406 wxGrid *arg1 = (wxGrid *) 0 ;
12407 bool result;
12408 void *argp1 = 0 ;
12409 int res1 = 0 ;
12410 PyObject *swig_obj[1] ;
12411
12412 if (!args) SWIG_fail;
12413 swig_obj[0] = args;
12414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12415 if (!SWIG_IsOK(res1)) {
12416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12417 }
12418 arg1 = reinterpret_cast< wxGrid * >(argp1);
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 result = (bool)(arg1)->MovePageDown();
12422 wxPyEndAllowThreads(__tstate);
12423 if (PyErr_Occurred()) SWIG_fail;
12424 }
12425 {
12426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12427 }
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12435 PyObject *resultobj = 0;
12436 wxGrid *arg1 = (wxGrid *) 0 ;
12437 bool result;
12438 void *argp1 = 0 ;
12439 int res1 = 0 ;
12440 PyObject *swig_obj[1] ;
12441
12442 if (!args) SWIG_fail;
12443 swig_obj[0] = args;
12444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12445 if (!SWIG_IsOK(res1)) {
12446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12447 }
12448 arg1 = reinterpret_cast< wxGrid * >(argp1);
12449 {
12450 PyThreadState* __tstate = wxPyBeginAllowThreads();
12451 result = (bool)(arg1)->MovePageUp();
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 {
12456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj = 0;
12466 wxGrid *arg1 = (wxGrid *) 0 ;
12467 bool arg2 ;
12468 bool result;
12469 void *argp1 = 0 ;
12470 int res1 = 0 ;
12471 bool val2 ;
12472 int ecode2 = 0 ;
12473 PyObject * obj0 = 0 ;
12474 PyObject * obj1 = 0 ;
12475 char * kwnames[] = {
12476 (char *) "self",(char *) "expandSelection", NULL
12477 };
12478
12479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12481 if (!SWIG_IsOK(res1)) {
12482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12483 }
12484 arg1 = reinterpret_cast< wxGrid * >(argp1);
12485 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12486 if (!SWIG_IsOK(ecode2)) {
12487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12488 }
12489 arg2 = static_cast< bool >(val2);
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12498 }
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj = 0;
12507 wxGrid *arg1 = (wxGrid *) 0 ;
12508 bool arg2 ;
12509 bool result;
12510 void *argp1 = 0 ;
12511 int res1 = 0 ;
12512 bool val2 ;
12513 int ecode2 = 0 ;
12514 PyObject * obj0 = 0 ;
12515 PyObject * obj1 = 0 ;
12516 char * kwnames[] = {
12517 (char *) "self",(char *) "expandSelection", NULL
12518 };
12519
12520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12522 if (!SWIG_IsOK(res1)) {
12523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12524 }
12525 arg1 = reinterpret_cast< wxGrid * >(argp1);
12526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12527 if (!SWIG_IsOK(ecode2)) {
12528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12529 }
12530 arg2 = static_cast< bool >(val2);
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 {
12538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12539 }
12540 return resultobj;
12541 fail:
12542 return NULL;
12543 }
12544
12545
12546 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12547 PyObject *resultobj = 0;
12548 wxGrid *arg1 = (wxGrid *) 0 ;
12549 bool arg2 ;
12550 bool result;
12551 void *argp1 = 0 ;
12552 int res1 = 0 ;
12553 bool val2 ;
12554 int ecode2 = 0 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 char * kwnames[] = {
12558 (char *) "self",(char *) "expandSelection", NULL
12559 };
12560
12561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12563 if (!SWIG_IsOK(res1)) {
12564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12565 }
12566 arg1 = reinterpret_cast< wxGrid * >(argp1);
12567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12568 if (!SWIG_IsOK(ecode2)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12570 }
12571 arg2 = static_cast< bool >(val2);
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 {
12579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12580 }
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj = 0;
12589 wxGrid *arg1 = (wxGrid *) 0 ;
12590 bool arg2 ;
12591 bool result;
12592 void *argp1 = 0 ;
12593 int res1 = 0 ;
12594 bool val2 ;
12595 int ecode2 = 0 ;
12596 PyObject * obj0 = 0 ;
12597 PyObject * obj1 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "self",(char *) "expandSelection", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12606 }
12607 arg1 = reinterpret_cast< wxGrid * >(argp1);
12608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12609 if (!SWIG_IsOK(ecode2)) {
12610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12611 }
12612 arg2 = static_cast< bool >(val2);
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 {
12620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12629 PyObject *resultobj = 0;
12630 wxGrid *arg1 = (wxGrid *) 0 ;
12631 int result;
12632 void *argp1 = 0 ;
12633 int res1 = 0 ;
12634 PyObject *swig_obj[1] ;
12635
12636 if (!args) SWIG_fail;
12637 swig_obj[0] = args;
12638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12639 if (!SWIG_IsOK(res1)) {
12640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12641 }
12642 arg1 = reinterpret_cast< wxGrid * >(argp1);
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 result = (int)(arg1)->GetDefaultRowLabelSize();
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 resultobj = SWIG_From_int(static_cast< int >(result));
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12657 PyObject *resultobj = 0;
12658 wxGrid *arg1 = (wxGrid *) 0 ;
12659 int result;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 PyObject *swig_obj[1] ;
12663
12664 if (!args) SWIG_fail;
12665 swig_obj[0] = args;
12666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12667 if (!SWIG_IsOK(res1)) {
12668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12669 }
12670 arg1 = reinterpret_cast< wxGrid * >(argp1);
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 result = (int)(arg1)->GetRowLabelSize();
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 resultobj = SWIG_From_int(static_cast< int >(result));
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxGrid *arg1 = (wxGrid *) 0 ;
12687 int result;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 PyObject *swig_obj[1] ;
12691
12692 if (!args) SWIG_fail;
12693 swig_obj[0] = args;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12697 }
12698 arg1 = reinterpret_cast< wxGrid * >(argp1);
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 result = (int)(arg1)->GetDefaultColLabelSize();
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 resultobj = SWIG_From_int(static_cast< int >(result));
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *resultobj = 0;
12714 wxGrid *arg1 = (wxGrid *) 0 ;
12715 int result;
12716 void *argp1 = 0 ;
12717 int res1 = 0 ;
12718 PyObject *swig_obj[1] ;
12719
12720 if (!args) SWIG_fail;
12721 swig_obj[0] = args;
12722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12723 if (!SWIG_IsOK(res1)) {
12724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12725 }
12726 arg1 = reinterpret_cast< wxGrid * >(argp1);
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (int)(arg1)->GetColLabelSize();
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 resultobj = SWIG_From_int(static_cast< int >(result));
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741 PyObject *resultobj = 0;
12742 wxGrid *arg1 = (wxGrid *) 0 ;
12743 wxColour result;
12744 void *argp1 = 0 ;
12745 int res1 = 0 ;
12746 PyObject *swig_obj[1] ;
12747
12748 if (!args) SWIG_fail;
12749 swig_obj[0] = args;
12750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12751 if (!SWIG_IsOK(res1)) {
12752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12753 }
12754 arg1 = reinterpret_cast< wxGrid * >(argp1);
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (arg1)->GetLabelBackgroundColour();
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12769 PyObject *resultobj = 0;
12770 wxGrid *arg1 = (wxGrid *) 0 ;
12771 wxColour result;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 PyObject *swig_obj[1] ;
12775
12776 if (!args) SWIG_fail;
12777 swig_obj[0] = args;
12778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12779 if (!SWIG_IsOK(res1)) {
12780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12781 }
12782 arg1 = reinterpret_cast< wxGrid * >(argp1);
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (arg1)->GetLabelTextColour();
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 PyObject *resultobj = 0;
12798 wxGrid *arg1 = (wxGrid *) 0 ;
12799 wxFont result;
12800 void *argp1 = 0 ;
12801 int res1 = 0 ;
12802 PyObject *swig_obj[1] ;
12803
12804 if (!args) SWIG_fail;
12805 swig_obj[0] = args;
12806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12807 if (!SWIG_IsOK(res1)) {
12808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12809 }
12810 arg1 = reinterpret_cast< wxGrid * >(argp1);
12811 {
12812 PyThreadState* __tstate = wxPyBeginAllowThreads();
12813 result = (arg1)->GetLabelFont();
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 PyObject *resultobj = 0;
12826 wxGrid *arg1 = (wxGrid *) 0 ;
12827 int *arg2 = (int *) 0 ;
12828 int *arg3 = (int *) 0 ;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 int temp2 ;
12832 int res2 = SWIG_TMPOBJ ;
12833 int temp3 ;
12834 int res3 = SWIG_TMPOBJ ;
12835 PyObject *swig_obj[1] ;
12836
12837 arg2 = &temp2;
12838 arg3 = &temp3;
12839 if (!args) SWIG_fail;
12840 swig_obj[0] = args;
12841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12842 if (!SWIG_IsOK(res1)) {
12843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12844 }
12845 arg1 = reinterpret_cast< wxGrid * >(argp1);
12846 {
12847 PyThreadState* __tstate = wxPyBeginAllowThreads();
12848 (arg1)->GetRowLabelAlignment(arg2,arg3);
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 resultobj = SWIG_Py_Void();
12853 if (SWIG_IsTmpObj(res2)) {
12854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12855 } else {
12856 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12858 }
12859 if (SWIG_IsTmpObj(res3)) {
12860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12861 } else {
12862 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12872 PyObject *resultobj = 0;
12873 wxGrid *arg1 = (wxGrid *) 0 ;
12874 int *arg2 = (int *) 0 ;
12875 int *arg3 = (int *) 0 ;
12876 void *argp1 = 0 ;
12877 int res1 = 0 ;
12878 int temp2 ;
12879 int res2 = SWIG_TMPOBJ ;
12880 int temp3 ;
12881 int res3 = SWIG_TMPOBJ ;
12882 PyObject *swig_obj[1] ;
12883
12884 arg2 = &temp2;
12885 arg3 = &temp3;
12886 if (!args) SWIG_fail;
12887 swig_obj[0] = args;
12888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12889 if (!SWIG_IsOK(res1)) {
12890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12891 }
12892 arg1 = reinterpret_cast< wxGrid * >(argp1);
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 (arg1)->GetColLabelAlignment(arg2,arg3);
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 resultobj = SWIG_Py_Void();
12900 if (SWIG_IsTmpObj(res2)) {
12901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12902 } else {
12903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12905 }
12906 if (SWIG_IsTmpObj(res3)) {
12907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12908 } else {
12909 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12911 }
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 PyObject *resultobj = 0;
12920 wxGrid *arg1 = (wxGrid *) 0 ;
12921 int result;
12922 void *argp1 = 0 ;
12923 int res1 = 0 ;
12924 PyObject *swig_obj[1] ;
12925
12926 if (!args) SWIG_fail;
12927 swig_obj[0] = args;
12928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12929 if (!SWIG_IsOK(res1)) {
12930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12931 }
12932 arg1 = reinterpret_cast< wxGrid * >(argp1);
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = (int)(arg1)->GetColLabelTextOrientation();
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 resultobj = SWIG_From_int(static_cast< int >(result));
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj = 0;
12948 wxGrid *arg1 = (wxGrid *) 0 ;
12949 int arg2 ;
12950 wxString result;
12951 void *argp1 = 0 ;
12952 int res1 = 0 ;
12953 int val2 ;
12954 int ecode2 = 0 ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char * kwnames[] = {
12958 (char *) "self",(char *) "row", NULL
12959 };
12960
12961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
12962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12963 if (!SWIG_IsOK(res1)) {
12964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12965 }
12966 arg1 = reinterpret_cast< wxGrid * >(argp1);
12967 ecode2 = SWIG_AsVal_int(obj1, &val2);
12968 if (!SWIG_IsOK(ecode2)) {
12969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
12970 }
12971 arg2 = static_cast< int >(val2);
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 result = (arg1)->GetRowLabelValue(arg2);
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 #if wxUSE_UNICODE
12980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12981 #else
12982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12983 #endif
12984 }
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = 0;
12993 wxGrid *arg1 = (wxGrid *) 0 ;
12994 int arg2 ;
12995 wxString result;
12996 void *argp1 = 0 ;
12997 int res1 = 0 ;
12998 int val2 ;
12999 int ecode2 = 0 ;
13000 PyObject * obj0 = 0 ;
13001 PyObject * obj1 = 0 ;
13002 char * kwnames[] = {
13003 (char *) "self",(char *) "col", NULL
13004 };
13005
13006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13008 if (!SWIG_IsOK(res1)) {
13009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13010 }
13011 arg1 = reinterpret_cast< wxGrid * >(argp1);
13012 ecode2 = SWIG_AsVal_int(obj1, &val2);
13013 if (!SWIG_IsOK(ecode2)) {
13014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13015 }
13016 arg2 = static_cast< int >(val2);
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (arg1)->GetColLabelValue(arg2);
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 {
13024 #if wxUSE_UNICODE
13025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13026 #else
13027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13028 #endif
13029 }
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13037 PyObject *resultobj = 0;
13038 wxGrid *arg1 = (wxGrid *) 0 ;
13039 wxColour result;
13040 void *argp1 = 0 ;
13041 int res1 = 0 ;
13042 PyObject *swig_obj[1] ;
13043
13044 if (!args) SWIG_fail;
13045 swig_obj[0] = args;
13046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13047 if (!SWIG_IsOK(res1)) {
13048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13049 }
13050 arg1 = reinterpret_cast< wxGrid * >(argp1);
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 result = (arg1)->GetGridLineColour();
13054 wxPyEndAllowThreads(__tstate);
13055 if (PyErr_Occurred()) SWIG_fail;
13056 }
13057 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13065 PyObject *resultobj = 0;
13066 wxGrid *arg1 = (wxGrid *) 0 ;
13067 wxColour result;
13068 void *argp1 = 0 ;
13069 int res1 = 0 ;
13070 PyObject *swig_obj[1] ;
13071
13072 if (!args) SWIG_fail;
13073 swig_obj[0] = args;
13074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13075 if (!SWIG_IsOK(res1)) {
13076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13077 }
13078 arg1 = reinterpret_cast< wxGrid * >(argp1);
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (arg1)->GetCellHighlightColour();
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13086 return resultobj;
13087 fail:
13088 return NULL;
13089 }
13090
13091
13092 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13093 PyObject *resultobj = 0;
13094 wxGrid *arg1 = (wxGrid *) 0 ;
13095 int result;
13096 void *argp1 = 0 ;
13097 int res1 = 0 ;
13098 PyObject *swig_obj[1] ;
13099
13100 if (!args) SWIG_fail;
13101 swig_obj[0] = args;
13102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13103 if (!SWIG_IsOK(res1)) {
13104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13105 }
13106 arg1 = reinterpret_cast< wxGrid * >(argp1);
13107 {
13108 PyThreadState* __tstate = wxPyBeginAllowThreads();
13109 result = (int)(arg1)->GetCellHighlightPenWidth();
13110 wxPyEndAllowThreads(__tstate);
13111 if (PyErr_Occurred()) SWIG_fail;
13112 }
13113 resultobj = SWIG_From_int(static_cast< int >(result));
13114 return resultobj;
13115 fail:
13116 return NULL;
13117 }
13118
13119
13120 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13121 PyObject *resultobj = 0;
13122 wxGrid *arg1 = (wxGrid *) 0 ;
13123 int result;
13124 void *argp1 = 0 ;
13125 int res1 = 0 ;
13126 PyObject *swig_obj[1] ;
13127
13128 if (!args) SWIG_fail;
13129 swig_obj[0] = args;
13130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13131 if (!SWIG_IsOK(res1)) {
13132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13133 }
13134 arg1 = reinterpret_cast< wxGrid * >(argp1);
13135 {
13136 PyThreadState* __tstate = wxPyBeginAllowThreads();
13137 result = (int)(arg1)->GetCellHighlightROPenWidth();
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 resultobj = SWIG_From_int(static_cast< int >(result));
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 wxGrid *arg1 = (wxGrid *) 0 ;
13151 int arg2 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 int val2 ;
13155 int ecode2 = 0 ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "self",(char *) "width", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13166 }
13167 arg1 = reinterpret_cast< wxGrid * >(argp1);
13168 ecode2 = SWIG_AsVal_int(obj1, &val2);
13169 if (!SWIG_IsOK(ecode2)) {
13170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13171 }
13172 arg2 = static_cast< int >(val2);
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 (arg1)->SetRowLabelSize(arg2);
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 resultobj = SWIG_Py_Void();
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj = 0;
13188 wxGrid *arg1 = (wxGrid *) 0 ;
13189 int arg2 ;
13190 void *argp1 = 0 ;
13191 int res1 = 0 ;
13192 int val2 ;
13193 int ecode2 = 0 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 char * kwnames[] = {
13197 (char *) "self",(char *) "height", NULL
13198 };
13199
13200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13202 if (!SWIG_IsOK(res1)) {
13203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13204 }
13205 arg1 = reinterpret_cast< wxGrid * >(argp1);
13206 ecode2 = SWIG_AsVal_int(obj1, &val2);
13207 if (!SWIG_IsOK(ecode2)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13209 }
13210 arg2 = static_cast< int >(val2);
13211 {
13212 PyThreadState* __tstate = wxPyBeginAllowThreads();
13213 (arg1)->SetColLabelSize(arg2);
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 resultobj = SWIG_Py_Void();
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13225 PyObject *resultobj = 0;
13226 wxGrid *arg1 = (wxGrid *) 0 ;
13227 wxColour *arg2 = 0 ;
13228 void *argp1 = 0 ;
13229 int res1 = 0 ;
13230 wxColour temp2 ;
13231 PyObject * obj0 = 0 ;
13232 PyObject * obj1 = 0 ;
13233 char * kwnames[] = {
13234 (char *) "self",(char *)"arg2", NULL
13235 };
13236
13237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13239 if (!SWIG_IsOK(res1)) {
13240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13241 }
13242 arg1 = reinterpret_cast< wxGrid * >(argp1);
13243 {
13244 arg2 = &temp2;
13245 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13246 }
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_Py_Void();
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13261 PyObject *resultobj = 0;
13262 wxGrid *arg1 = (wxGrid *) 0 ;
13263 wxColour *arg2 = 0 ;
13264 void *argp1 = 0 ;
13265 int res1 = 0 ;
13266 wxColour temp2 ;
13267 PyObject * obj0 = 0 ;
13268 PyObject * obj1 = 0 ;
13269 char * kwnames[] = {
13270 (char *) "self",(char *)"arg2", NULL
13271 };
13272
13273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13275 if (!SWIG_IsOK(res1)) {
13276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13277 }
13278 arg1 = reinterpret_cast< wxGrid * >(argp1);
13279 {
13280 arg2 = &temp2;
13281 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13282 }
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 resultobj = SWIG_Py_Void();
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj = 0;
13298 wxGrid *arg1 = (wxGrid *) 0 ;
13299 wxFont *arg2 = 0 ;
13300 void *argp1 = 0 ;
13301 int res1 = 0 ;
13302 void *argp2 = 0 ;
13303 int res2 = 0 ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 char * kwnames[] = {
13307 (char *) "self",(char *)"arg2", NULL
13308 };
13309
13310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13312 if (!SWIG_IsOK(res1)) {
13313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13314 }
13315 arg1 = reinterpret_cast< wxGrid * >(argp1);
13316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13317 if (!SWIG_IsOK(res2)) {
13318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13319 }
13320 if (!argp2) {
13321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13322 }
13323 arg2 = reinterpret_cast< wxFont * >(argp2);
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 (arg1)->SetLabelFont((wxFont const &)*arg2);
13327 wxPyEndAllowThreads(__tstate);
13328 if (PyErr_Occurred()) SWIG_fail;
13329 }
13330 resultobj = SWIG_Py_Void();
13331 return resultobj;
13332 fail:
13333 return NULL;
13334 }
13335
13336
13337 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13338 PyObject *resultobj = 0;
13339 wxGrid *arg1 = (wxGrid *) 0 ;
13340 int arg2 ;
13341 int arg3 ;
13342 void *argp1 = 0 ;
13343 int res1 = 0 ;
13344 int val2 ;
13345 int ecode2 = 0 ;
13346 int val3 ;
13347 int ecode3 = 0 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 PyObject * obj2 = 0 ;
13351 char * kwnames[] = {
13352 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13353 };
13354
13355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13357 if (!SWIG_IsOK(res1)) {
13358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13359 }
13360 arg1 = reinterpret_cast< wxGrid * >(argp1);
13361 ecode2 = SWIG_AsVal_int(obj1, &val2);
13362 if (!SWIG_IsOK(ecode2)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13364 }
13365 arg2 = static_cast< int >(val2);
13366 ecode3 = SWIG_AsVal_int(obj2, &val3);
13367 if (!SWIG_IsOK(ecode3)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13369 }
13370 arg3 = static_cast< int >(val3);
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 (arg1)->SetRowLabelAlignment(arg2,arg3);
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 resultobj = SWIG_Py_Void();
13378 return resultobj;
13379 fail:
13380 return NULL;
13381 }
13382
13383
13384 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13385 PyObject *resultobj = 0;
13386 wxGrid *arg1 = (wxGrid *) 0 ;
13387 int arg2 ;
13388 int arg3 ;
13389 void *argp1 = 0 ;
13390 int res1 = 0 ;
13391 int val2 ;
13392 int ecode2 = 0 ;
13393 int val3 ;
13394 int ecode3 = 0 ;
13395 PyObject * obj0 = 0 ;
13396 PyObject * obj1 = 0 ;
13397 PyObject * obj2 = 0 ;
13398 char * kwnames[] = {
13399 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13400 };
13401
13402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13404 if (!SWIG_IsOK(res1)) {
13405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13406 }
13407 arg1 = reinterpret_cast< wxGrid * >(argp1);
13408 ecode2 = SWIG_AsVal_int(obj1, &val2);
13409 if (!SWIG_IsOK(ecode2)) {
13410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13411 }
13412 arg2 = static_cast< int >(val2);
13413 ecode3 = SWIG_AsVal_int(obj2, &val3);
13414 if (!SWIG_IsOK(ecode3)) {
13415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13416 }
13417 arg3 = static_cast< int >(val3);
13418 {
13419 PyThreadState* __tstate = wxPyBeginAllowThreads();
13420 (arg1)->SetColLabelAlignment(arg2,arg3);
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 resultobj = SWIG_Py_Void();
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13432 PyObject *resultobj = 0;
13433 wxGrid *arg1 = (wxGrid *) 0 ;
13434 int arg2 ;
13435 void *argp1 = 0 ;
13436 int res1 = 0 ;
13437 int val2 ;
13438 int ecode2 = 0 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 char * kwnames[] = {
13442 (char *) "self",(char *) "textOrientation", NULL
13443 };
13444
13445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13447 if (!SWIG_IsOK(res1)) {
13448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13449 }
13450 arg1 = reinterpret_cast< wxGrid * >(argp1);
13451 ecode2 = SWIG_AsVal_int(obj1, &val2);
13452 if (!SWIG_IsOK(ecode2)) {
13453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13454 }
13455 arg2 = static_cast< int >(val2);
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 (arg1)->SetColLabelTextOrientation(arg2);
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 resultobj = SWIG_Py_Void();
13463 return resultobj;
13464 fail:
13465 return NULL;
13466 }
13467
13468
13469 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13470 PyObject *resultobj = 0;
13471 wxGrid *arg1 = (wxGrid *) 0 ;
13472 int arg2 ;
13473 wxString *arg3 = 0 ;
13474 void *argp1 = 0 ;
13475 int res1 = 0 ;
13476 int val2 ;
13477 int ecode2 = 0 ;
13478 bool temp3 = false ;
13479 PyObject * obj0 = 0 ;
13480 PyObject * obj1 = 0 ;
13481 PyObject * obj2 = 0 ;
13482 char * kwnames[] = {
13483 (char *) "self",(char *) "row",(char *)"arg3", NULL
13484 };
13485
13486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13488 if (!SWIG_IsOK(res1)) {
13489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13490 }
13491 arg1 = reinterpret_cast< wxGrid * >(argp1);
13492 ecode2 = SWIG_AsVal_int(obj1, &val2);
13493 if (!SWIG_IsOK(ecode2)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13495 }
13496 arg2 = static_cast< int >(val2);
13497 {
13498 arg3 = wxString_in_helper(obj2);
13499 if (arg3 == NULL) SWIG_fail;
13500 temp3 = true;
13501 }
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 resultobj = SWIG_Py_Void();
13509 {
13510 if (temp3)
13511 delete arg3;
13512 }
13513 return resultobj;
13514 fail:
13515 {
13516 if (temp3)
13517 delete arg3;
13518 }
13519 return NULL;
13520 }
13521
13522
13523 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13524 PyObject *resultobj = 0;
13525 wxGrid *arg1 = (wxGrid *) 0 ;
13526 int arg2 ;
13527 wxString *arg3 = 0 ;
13528 void *argp1 = 0 ;
13529 int res1 = 0 ;
13530 int val2 ;
13531 int ecode2 = 0 ;
13532 bool temp3 = false ;
13533 PyObject * obj0 = 0 ;
13534 PyObject * obj1 = 0 ;
13535 PyObject * obj2 = 0 ;
13536 char * kwnames[] = {
13537 (char *) "self",(char *) "col",(char *)"arg3", NULL
13538 };
13539
13540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13542 if (!SWIG_IsOK(res1)) {
13543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13544 }
13545 arg1 = reinterpret_cast< wxGrid * >(argp1);
13546 ecode2 = SWIG_AsVal_int(obj1, &val2);
13547 if (!SWIG_IsOK(ecode2)) {
13548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13549 }
13550 arg2 = static_cast< int >(val2);
13551 {
13552 arg3 = wxString_in_helper(obj2);
13553 if (arg3 == NULL) SWIG_fail;
13554 temp3 = true;
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_Py_Void();
13563 {
13564 if (temp3)
13565 delete arg3;
13566 }
13567 return resultobj;
13568 fail:
13569 {
13570 if (temp3)
13571 delete arg3;
13572 }
13573 return NULL;
13574 }
13575
13576
13577 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 wxGrid *arg1 = (wxGrid *) 0 ;
13580 wxColour *arg2 = 0 ;
13581 void *argp1 = 0 ;
13582 int res1 = 0 ;
13583 wxColour temp2 ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "self",(char *)"arg2", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13592 if (!SWIG_IsOK(res1)) {
13593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13594 }
13595 arg1 = reinterpret_cast< wxGrid * >(argp1);
13596 {
13597 arg2 = &temp2;
13598 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13599 }
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_Py_Void();
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj = 0;
13615 wxGrid *arg1 = (wxGrid *) 0 ;
13616 wxColour *arg2 = 0 ;
13617 void *argp1 = 0 ;
13618 int res1 = 0 ;
13619 wxColour temp2 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 char * kwnames[] = {
13623 (char *) "self",(char *)"arg2", NULL
13624 };
13625
13626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13628 if (!SWIG_IsOK(res1)) {
13629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13630 }
13631 arg1 = reinterpret_cast< wxGrid * >(argp1);
13632 {
13633 arg2 = &temp2;
13634 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13635 }
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 (arg1)->SetCellHighlightColour((wxColour const &)*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_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxGrid *arg1 = (wxGrid *) 0 ;
13652 int arg2 ;
13653 void *argp1 = 0 ;
13654 int res1 = 0 ;
13655 int val2 ;
13656 int ecode2 = 0 ;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 char * kwnames[] = {
13660 (char *) "self",(char *) "width", NULL
13661 };
13662
13663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13665 if (!SWIG_IsOK(res1)) {
13666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13667 }
13668 arg1 = reinterpret_cast< wxGrid * >(argp1);
13669 ecode2 = SWIG_AsVal_int(obj1, &val2);
13670 if (!SWIG_IsOK(ecode2)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13672 }
13673 arg2 = static_cast< int >(val2);
13674 {
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 (arg1)->SetCellHighlightPenWidth(arg2);
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 resultobj = SWIG_Py_Void();
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj = 0;
13689 wxGrid *arg1 = (wxGrid *) 0 ;
13690 int arg2 ;
13691 void *argp1 = 0 ;
13692 int res1 = 0 ;
13693 int val2 ;
13694 int ecode2 = 0 ;
13695 PyObject * obj0 = 0 ;
13696 PyObject * obj1 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "width", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13705 }
13706 arg1 = reinterpret_cast< wxGrid * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 (arg1)->SetCellHighlightROPenWidth(arg2);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = SWIG_Py_Void();
13719 return resultobj;
13720 fail:
13721 return NULL;
13722 }
13723
13724
13725 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13726 PyObject *resultobj = 0;
13727 wxGrid *arg1 = (wxGrid *) 0 ;
13728 bool arg2 = (bool) true ;
13729 void *argp1 = 0 ;
13730 int res1 = 0 ;
13731 bool val2 ;
13732 int ecode2 = 0 ;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 char * kwnames[] = {
13736 (char *) "self",(char *) "enable", NULL
13737 };
13738
13739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13741 if (!SWIG_IsOK(res1)) {
13742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13743 }
13744 arg1 = reinterpret_cast< wxGrid * >(argp1);
13745 if (obj1) {
13746 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13747 if (!SWIG_IsOK(ecode2)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13749 }
13750 arg2 = static_cast< bool >(val2);
13751 }
13752 {
13753 PyThreadState* __tstate = wxPyBeginAllowThreads();
13754 (arg1)->EnableDragRowSize(arg2);
13755 wxPyEndAllowThreads(__tstate);
13756 if (PyErr_Occurred()) SWIG_fail;
13757 }
13758 resultobj = SWIG_Py_Void();
13759 return resultobj;
13760 fail:
13761 return NULL;
13762 }
13763
13764
13765 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13766 PyObject *resultobj = 0;
13767 wxGrid *arg1 = (wxGrid *) 0 ;
13768 void *argp1 = 0 ;
13769 int res1 = 0 ;
13770 PyObject *swig_obj[1] ;
13771
13772 if (!args) SWIG_fail;
13773 swig_obj[0] = args;
13774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13775 if (!SWIG_IsOK(res1)) {
13776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13777 }
13778 arg1 = reinterpret_cast< wxGrid * >(argp1);
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 (arg1)->DisableDragRowSize();
13782 wxPyEndAllowThreads(__tstate);
13783 if (PyErr_Occurred()) SWIG_fail;
13784 }
13785 resultobj = SWIG_Py_Void();
13786 return resultobj;
13787 fail:
13788 return NULL;
13789 }
13790
13791
13792 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13793 PyObject *resultobj = 0;
13794 wxGrid *arg1 = (wxGrid *) 0 ;
13795 bool result;
13796 void *argp1 = 0 ;
13797 int res1 = 0 ;
13798 PyObject *swig_obj[1] ;
13799
13800 if (!args) SWIG_fail;
13801 swig_obj[0] = args;
13802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13803 if (!SWIG_IsOK(res1)) {
13804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13805 }
13806 arg1 = reinterpret_cast< wxGrid * >(argp1);
13807 {
13808 PyThreadState* __tstate = wxPyBeginAllowThreads();
13809 result = (bool)(arg1)->CanDragRowSize();
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 {
13814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13815 }
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj = 0;
13824 wxGrid *arg1 = (wxGrid *) 0 ;
13825 bool arg2 = (bool) true ;
13826 void *argp1 = 0 ;
13827 int res1 = 0 ;
13828 bool val2 ;
13829 int ecode2 = 0 ;
13830 PyObject * obj0 = 0 ;
13831 PyObject * obj1 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "self",(char *) "enable", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13840 }
13841 arg1 = reinterpret_cast< wxGrid * >(argp1);
13842 if (obj1) {
13843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13844 if (!SWIG_IsOK(ecode2)) {
13845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13846 }
13847 arg2 = static_cast< bool >(val2);
13848 }
13849 {
13850 PyThreadState* __tstate = wxPyBeginAllowThreads();
13851 (arg1)->EnableDragColSize(arg2);
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 resultobj = SWIG_Py_Void();
13856 return resultobj;
13857 fail:
13858 return NULL;
13859 }
13860
13861
13862 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13863 PyObject *resultobj = 0;
13864 wxGrid *arg1 = (wxGrid *) 0 ;
13865 void *argp1 = 0 ;
13866 int res1 = 0 ;
13867 PyObject *swig_obj[1] ;
13868
13869 if (!args) SWIG_fail;
13870 swig_obj[0] = args;
13871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13872 if (!SWIG_IsOK(res1)) {
13873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13874 }
13875 arg1 = reinterpret_cast< wxGrid * >(argp1);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 (arg1)->DisableDragColSize();
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_Py_Void();
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13890 PyObject *resultobj = 0;
13891 wxGrid *arg1 = (wxGrid *) 0 ;
13892 bool result;
13893 void *argp1 = 0 ;
13894 int res1 = 0 ;
13895 PyObject *swig_obj[1] ;
13896
13897 if (!args) SWIG_fail;
13898 swig_obj[0] = args;
13899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13900 if (!SWIG_IsOK(res1)) {
13901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13902 }
13903 arg1 = reinterpret_cast< wxGrid * >(argp1);
13904 {
13905 PyThreadState* __tstate = wxPyBeginAllowThreads();
13906 result = (bool)(arg1)->CanDragColSize();
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 {
13911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13912 }
13913 return resultobj;
13914 fail:
13915 return NULL;
13916 }
13917
13918
13919 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj = 0;
13921 wxGrid *arg1 = (wxGrid *) 0 ;
13922 bool arg2 = (bool) true ;
13923 void *argp1 = 0 ;
13924 int res1 = 0 ;
13925 bool val2 ;
13926 int ecode2 = 0 ;
13927 PyObject * obj0 = 0 ;
13928 PyObject * obj1 = 0 ;
13929 char * kwnames[] = {
13930 (char *) "self",(char *) "enable", NULL
13931 };
13932
13933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
13934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13935 if (!SWIG_IsOK(res1)) {
13936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13937 }
13938 arg1 = reinterpret_cast< wxGrid * >(argp1);
13939 if (obj1) {
13940 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13941 if (!SWIG_IsOK(ecode2)) {
13942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
13943 }
13944 arg2 = static_cast< bool >(val2);
13945 }
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 (arg1)->EnableDragGridSize(arg2);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13960 PyObject *resultobj = 0;
13961 wxGrid *arg1 = (wxGrid *) 0 ;
13962 void *argp1 = 0 ;
13963 int res1 = 0 ;
13964 PyObject *swig_obj[1] ;
13965
13966 if (!args) SWIG_fail;
13967 swig_obj[0] = args;
13968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13969 if (!SWIG_IsOK(res1)) {
13970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13971 }
13972 arg1 = reinterpret_cast< wxGrid * >(argp1);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 (arg1)->DisableDragGridSize();
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_Py_Void();
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13987 PyObject *resultobj = 0;
13988 wxGrid *arg1 = (wxGrid *) 0 ;
13989 bool result;
13990 void *argp1 = 0 ;
13991 int res1 = 0 ;
13992 PyObject *swig_obj[1] ;
13993
13994 if (!args) SWIG_fail;
13995 swig_obj[0] = args;
13996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13999 }
14000 arg1 = reinterpret_cast< wxGrid * >(argp1);
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 result = (bool)(arg1)->CanDragGridSize();
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 {
14008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14009 }
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14017 PyObject *resultobj = 0;
14018 wxGrid *arg1 = (wxGrid *) 0 ;
14019 bool arg2 = (bool) true ;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 bool val2 ;
14023 int ecode2 = 0 ;
14024 PyObject * obj0 = 0 ;
14025 PyObject * obj1 = 0 ;
14026 char * kwnames[] = {
14027 (char *) "self",(char *) "enable", NULL
14028 };
14029
14030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14032 if (!SWIG_IsOK(res1)) {
14033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14034 }
14035 arg1 = reinterpret_cast< wxGrid * >(argp1);
14036 if (obj1) {
14037 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14038 if (!SWIG_IsOK(ecode2)) {
14039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14040 }
14041 arg2 = static_cast< bool >(val2);
14042 }
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 (arg1)->EnableDragCell(arg2);
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 resultobj = SWIG_Py_Void();
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxGrid *arg1 = (wxGrid *) 0 ;
14059 void *argp1 = 0 ;
14060 int res1 = 0 ;
14061 PyObject *swig_obj[1] ;
14062
14063 if (!args) SWIG_fail;
14064 swig_obj[0] = args;
14065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14068 }
14069 arg1 = reinterpret_cast< wxGrid * >(argp1);
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 (arg1)->DisableDragCell();
14073 wxPyEndAllowThreads(__tstate);
14074 if (PyErr_Occurred()) SWIG_fail;
14075 }
14076 resultobj = SWIG_Py_Void();
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14084 PyObject *resultobj = 0;
14085 wxGrid *arg1 = (wxGrid *) 0 ;
14086 bool result;
14087 void *argp1 = 0 ;
14088 int res1 = 0 ;
14089 PyObject *swig_obj[1] ;
14090
14091 if (!args) SWIG_fail;
14092 swig_obj[0] = args;
14093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14096 }
14097 arg1 = reinterpret_cast< wxGrid * >(argp1);
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 result = (bool)(arg1)->CanDragCell();
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 {
14105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14106 }
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj = 0;
14115 wxGrid *arg1 = (wxGrid *) 0 ;
14116 int arg2 ;
14117 int arg3 ;
14118 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 int val2 ;
14122 int ecode2 = 0 ;
14123 int val3 ;
14124 int ecode3 = 0 ;
14125 void *argp4 = 0 ;
14126 int res4 = 0 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 PyObject * obj2 = 0 ;
14130 PyObject * obj3 = 0 ;
14131 char * kwnames[] = {
14132 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14133 };
14134
14135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14137 if (!SWIG_IsOK(res1)) {
14138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14139 }
14140 arg1 = reinterpret_cast< wxGrid * >(argp1);
14141 ecode2 = SWIG_AsVal_int(obj1, &val2);
14142 if (!SWIG_IsOK(ecode2)) {
14143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14144 }
14145 arg2 = static_cast< int >(val2);
14146 ecode3 = SWIG_AsVal_int(obj2, &val3);
14147 if (!SWIG_IsOK(ecode3)) {
14148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14149 }
14150 arg3 = static_cast< int >(val3);
14151 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14152 if (!SWIG_IsOK(res4)) {
14153 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14154 }
14155 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14156 {
14157 PyThreadState* __tstate = wxPyBeginAllowThreads();
14158 (arg1)->SetAttr(arg2,arg3,arg4);
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = SWIG_Py_Void();
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj = 0;
14171 wxGrid *arg1 = (wxGrid *) 0 ;
14172 int arg2 ;
14173 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14174 void *argp1 = 0 ;
14175 int res1 = 0 ;
14176 int val2 ;
14177 int ecode2 = 0 ;
14178 void *argp3 = 0 ;
14179 int res3 = 0 ;
14180 PyObject * obj0 = 0 ;
14181 PyObject * obj1 = 0 ;
14182 PyObject * obj2 = 0 ;
14183 char * kwnames[] = {
14184 (char *) "self",(char *) "row",(char *) "attr", NULL
14185 };
14186
14187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14189 if (!SWIG_IsOK(res1)) {
14190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14191 }
14192 arg1 = reinterpret_cast< wxGrid * >(argp1);
14193 ecode2 = SWIG_AsVal_int(obj1, &val2);
14194 if (!SWIG_IsOK(ecode2)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14196 }
14197 arg2 = static_cast< int >(val2);
14198 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14199 if (!SWIG_IsOK(res3)) {
14200 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14201 }
14202 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 (arg1)->SetRowAttr(arg2,arg3);
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 resultobj = SWIG_Py_Void();
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj = 0;
14218 wxGrid *arg1 = (wxGrid *) 0 ;
14219 int arg2 ;
14220 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 int val2 ;
14224 int ecode2 = 0 ;
14225 void *argp3 = 0 ;
14226 int res3 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 PyObject * obj2 = 0 ;
14230 char * kwnames[] = {
14231 (char *) "self",(char *) "col",(char *) "attr", NULL
14232 };
14233
14234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14236 if (!SWIG_IsOK(res1)) {
14237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14238 }
14239 arg1 = reinterpret_cast< wxGrid * >(argp1);
14240 ecode2 = SWIG_AsVal_int(obj1, &val2);
14241 if (!SWIG_IsOK(ecode2)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14243 }
14244 arg2 = static_cast< int >(val2);
14245 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14246 if (!SWIG_IsOK(res3)) {
14247 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14248 }
14249 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 (arg1)->SetColAttr(arg2,arg3);
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 resultobj = SWIG_Py_Void();
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj = 0;
14265 wxGrid *arg1 = (wxGrid *) 0 ;
14266 int arg2 ;
14267 int arg3 ;
14268 wxGridCellAttr *result = 0 ;
14269 void *argp1 = 0 ;
14270 int res1 = 0 ;
14271 int val2 ;
14272 int ecode2 = 0 ;
14273 int val3 ;
14274 int ecode3 = 0 ;
14275 PyObject * obj0 = 0 ;
14276 PyObject * obj1 = 0 ;
14277 PyObject * obj2 = 0 ;
14278 char * kwnames[] = {
14279 (char *) "self",(char *) "row",(char *) "col", NULL
14280 };
14281
14282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14284 if (!SWIG_IsOK(res1)) {
14285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14286 }
14287 arg1 = reinterpret_cast< wxGrid * >(argp1);
14288 ecode2 = SWIG_AsVal_int(obj1, &val2);
14289 if (!SWIG_IsOK(ecode2)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14291 }
14292 arg2 = static_cast< int >(val2);
14293 ecode3 = SWIG_AsVal_int(obj2, &val3);
14294 if (!SWIG_IsOK(ecode3)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14296 }
14297 arg3 = static_cast< int >(val3);
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14301 wxPyEndAllowThreads(__tstate);
14302 if (PyErr_Occurred()) SWIG_fail;
14303 }
14304 {
14305 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14306 }
14307 return resultobj;
14308 fail:
14309 return NULL;
14310 }
14311
14312
14313 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14314 PyObject *resultobj = 0;
14315 wxGrid *arg1 = (wxGrid *) 0 ;
14316 int arg2 ;
14317 void *argp1 = 0 ;
14318 int res1 = 0 ;
14319 int val2 ;
14320 int ecode2 = 0 ;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 char * kwnames[] = {
14324 (char *) "self",(char *) "col", NULL
14325 };
14326
14327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14329 if (!SWIG_IsOK(res1)) {
14330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14331 }
14332 arg1 = reinterpret_cast< wxGrid * >(argp1);
14333 ecode2 = SWIG_AsVal_int(obj1, &val2);
14334 if (!SWIG_IsOK(ecode2)) {
14335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14336 }
14337 arg2 = static_cast< int >(val2);
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->SetColFormatBool(arg2);
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_Py_Void();
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14352 PyObject *resultobj = 0;
14353 wxGrid *arg1 = (wxGrid *) 0 ;
14354 int arg2 ;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 int val2 ;
14358 int ecode2 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 char * kwnames[] = {
14362 (char *) "self",(char *) "col", NULL
14363 };
14364
14365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14369 }
14370 arg1 = reinterpret_cast< wxGrid * >(argp1);
14371 ecode2 = SWIG_AsVal_int(obj1, &val2);
14372 if (!SWIG_IsOK(ecode2)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14374 }
14375 arg2 = static_cast< int >(val2);
14376 {
14377 PyThreadState* __tstate = wxPyBeginAllowThreads();
14378 (arg1)->SetColFormatNumber(arg2);
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 resultobj = SWIG_Py_Void();
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj = 0;
14391 wxGrid *arg1 = (wxGrid *) 0 ;
14392 int arg2 ;
14393 int arg3 = (int) -1 ;
14394 int arg4 = (int) -1 ;
14395 void *argp1 = 0 ;
14396 int res1 = 0 ;
14397 int val2 ;
14398 int ecode2 = 0 ;
14399 int val3 ;
14400 int ecode3 = 0 ;
14401 int val4 ;
14402 int ecode4 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 PyObject * obj2 = 0 ;
14406 PyObject * obj3 = 0 ;
14407 char * kwnames[] = {
14408 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14409 };
14410
14411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14413 if (!SWIG_IsOK(res1)) {
14414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14415 }
14416 arg1 = reinterpret_cast< wxGrid * >(argp1);
14417 ecode2 = SWIG_AsVal_int(obj1, &val2);
14418 if (!SWIG_IsOK(ecode2)) {
14419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14420 }
14421 arg2 = static_cast< int >(val2);
14422 if (obj2) {
14423 ecode3 = SWIG_AsVal_int(obj2, &val3);
14424 if (!SWIG_IsOK(ecode3)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14426 }
14427 arg3 = static_cast< int >(val3);
14428 }
14429 if (obj3) {
14430 ecode4 = SWIG_AsVal_int(obj3, &val4);
14431 if (!SWIG_IsOK(ecode4)) {
14432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14433 }
14434 arg4 = static_cast< int >(val4);
14435 }
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = SWIG_Py_Void();
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj = 0;
14451 wxGrid *arg1 = (wxGrid *) 0 ;
14452 int arg2 ;
14453 wxString *arg3 = 0 ;
14454 void *argp1 = 0 ;
14455 int res1 = 0 ;
14456 int val2 ;
14457 int ecode2 = 0 ;
14458 bool temp3 = false ;
14459 PyObject * obj0 = 0 ;
14460 PyObject * obj1 = 0 ;
14461 PyObject * obj2 = 0 ;
14462 char * kwnames[] = {
14463 (char *) "self",(char *) "col",(char *) "typeName", NULL
14464 };
14465
14466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14468 if (!SWIG_IsOK(res1)) {
14469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14470 }
14471 arg1 = reinterpret_cast< wxGrid * >(argp1);
14472 ecode2 = SWIG_AsVal_int(obj1, &val2);
14473 if (!SWIG_IsOK(ecode2)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14475 }
14476 arg2 = static_cast< int >(val2);
14477 {
14478 arg3 = wxString_in_helper(obj2);
14479 if (arg3 == NULL) SWIG_fail;
14480 temp3 = true;
14481 }
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 resultobj = SWIG_Py_Void();
14489 {
14490 if (temp3)
14491 delete arg3;
14492 }
14493 return resultobj;
14494 fail:
14495 {
14496 if (temp3)
14497 delete arg3;
14498 }
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj = 0;
14505 wxGrid *arg1 = (wxGrid *) 0 ;
14506 bool arg2 = (bool) true ;
14507 void *argp1 = 0 ;
14508 int res1 = 0 ;
14509 bool val2 ;
14510 int ecode2 = 0 ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "self",(char *) "enable", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14521 }
14522 arg1 = reinterpret_cast< wxGrid * >(argp1);
14523 if (obj1) {
14524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14525 if (!SWIG_IsOK(ecode2)) {
14526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14527 }
14528 arg2 = static_cast< bool >(val2);
14529 }
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 (arg1)->EnableGridLines(arg2);
14533 wxPyEndAllowThreads(__tstate);
14534 if (PyErr_Occurred()) SWIG_fail;
14535 }
14536 resultobj = SWIG_Py_Void();
14537 return resultobj;
14538 fail:
14539 return NULL;
14540 }
14541
14542
14543 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14544 PyObject *resultobj = 0;
14545 wxGrid *arg1 = (wxGrid *) 0 ;
14546 bool result;
14547 void *argp1 = 0 ;
14548 int res1 = 0 ;
14549 PyObject *swig_obj[1] ;
14550
14551 if (!args) SWIG_fail;
14552 swig_obj[0] = args;
14553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14554 if (!SWIG_IsOK(res1)) {
14555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14556 }
14557 arg1 = reinterpret_cast< wxGrid * >(argp1);
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (bool)(arg1)->GridLinesEnabled();
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 {
14565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14566 }
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14574 PyObject *resultobj = 0;
14575 wxGrid *arg1 = (wxGrid *) 0 ;
14576 int result;
14577 void *argp1 = 0 ;
14578 int res1 = 0 ;
14579 PyObject *swig_obj[1] ;
14580
14581 if (!args) SWIG_fail;
14582 swig_obj[0] = args;
14583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14584 if (!SWIG_IsOK(res1)) {
14585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14586 }
14587 arg1 = reinterpret_cast< wxGrid * >(argp1);
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (int)(arg1)->GetDefaultRowSize();
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 resultobj = SWIG_From_int(static_cast< int >(result));
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14602 PyObject *resultobj = 0;
14603 wxGrid *arg1 = (wxGrid *) 0 ;
14604 int arg2 ;
14605 int result;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 int val2 ;
14609 int ecode2 = 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 char * kwnames[] = {
14613 (char *) "self",(char *) "row", NULL
14614 };
14615
14616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14618 if (!SWIG_IsOK(res1)) {
14619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14620 }
14621 arg1 = reinterpret_cast< wxGrid * >(argp1);
14622 ecode2 = SWIG_AsVal_int(obj1, &val2);
14623 if (!SWIG_IsOK(ecode2)) {
14624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14625 }
14626 arg2 = static_cast< int >(val2);
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 result = (int)(arg1)->GetRowSize(arg2);
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 resultobj = SWIG_From_int(static_cast< int >(result));
14634 return resultobj;
14635 fail:
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14641 PyObject *resultobj = 0;
14642 wxGrid *arg1 = (wxGrid *) 0 ;
14643 int result;
14644 void *argp1 = 0 ;
14645 int res1 = 0 ;
14646 PyObject *swig_obj[1] ;
14647
14648 if (!args) SWIG_fail;
14649 swig_obj[0] = args;
14650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14653 }
14654 arg1 = reinterpret_cast< wxGrid * >(argp1);
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (int)(arg1)->GetDefaultColSize();
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 resultobj = SWIG_From_int(static_cast< int >(result));
14662 return resultobj;
14663 fail:
14664 return NULL;
14665 }
14666
14667
14668 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14669 PyObject *resultobj = 0;
14670 wxGrid *arg1 = (wxGrid *) 0 ;
14671 int arg2 ;
14672 int result;
14673 void *argp1 = 0 ;
14674 int res1 = 0 ;
14675 int val2 ;
14676 int ecode2 = 0 ;
14677 PyObject * obj0 = 0 ;
14678 PyObject * obj1 = 0 ;
14679 char * kwnames[] = {
14680 (char *) "self",(char *) "col", NULL
14681 };
14682
14683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14685 if (!SWIG_IsOK(res1)) {
14686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14687 }
14688 arg1 = reinterpret_cast< wxGrid * >(argp1);
14689 ecode2 = SWIG_AsVal_int(obj1, &val2);
14690 if (!SWIG_IsOK(ecode2)) {
14691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14692 }
14693 arg2 = static_cast< int >(val2);
14694 {
14695 PyThreadState* __tstate = wxPyBeginAllowThreads();
14696 result = (int)(arg1)->GetColSize(arg2);
14697 wxPyEndAllowThreads(__tstate);
14698 if (PyErr_Occurred()) SWIG_fail;
14699 }
14700 resultobj = SWIG_From_int(static_cast< int >(result));
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14708 PyObject *resultobj = 0;
14709 wxGrid *arg1 = (wxGrid *) 0 ;
14710 wxColour result;
14711 void *argp1 = 0 ;
14712 int res1 = 0 ;
14713 PyObject *swig_obj[1] ;
14714
14715 if (!args) SWIG_fail;
14716 swig_obj[0] = args;
14717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14720 }
14721 arg1 = reinterpret_cast< wxGrid * >(argp1);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (arg1)->GetDefaultCellBackgroundColour();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 wxGrid *arg1 = (wxGrid *) 0 ;
14738 int arg2 ;
14739 int arg3 ;
14740 wxColour result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 int val2 ;
14744 int ecode2 = 0 ;
14745 int val3 ;
14746 int ecode3 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 char * kwnames[] = {
14751 (char *) "self",(char *) "row",(char *) "col", NULL
14752 };
14753
14754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14756 if (!SWIG_IsOK(res1)) {
14757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14758 }
14759 arg1 = reinterpret_cast< wxGrid * >(argp1);
14760 ecode2 = SWIG_AsVal_int(obj1, &val2);
14761 if (!SWIG_IsOK(ecode2)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14763 }
14764 arg2 = static_cast< int >(val2);
14765 ecode3 = SWIG_AsVal_int(obj2, &val3);
14766 if (!SWIG_IsOK(ecode3)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14768 }
14769 arg3 = static_cast< int >(val3);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14784 PyObject *resultobj = 0;
14785 wxGrid *arg1 = (wxGrid *) 0 ;
14786 wxColour result;
14787 void *argp1 = 0 ;
14788 int res1 = 0 ;
14789 PyObject *swig_obj[1] ;
14790
14791 if (!args) SWIG_fail;
14792 swig_obj[0] = args;
14793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14794 if (!SWIG_IsOK(res1)) {
14795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14796 }
14797 arg1 = reinterpret_cast< wxGrid * >(argp1);
14798 {
14799 PyThreadState* __tstate = wxPyBeginAllowThreads();
14800 result = (arg1)->GetDefaultCellTextColour();
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14805 return resultobj;
14806 fail:
14807 return NULL;
14808 }
14809
14810
14811 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj = 0;
14813 wxGrid *arg1 = (wxGrid *) 0 ;
14814 int arg2 ;
14815 int arg3 ;
14816 wxColour result;
14817 void *argp1 = 0 ;
14818 int res1 = 0 ;
14819 int val2 ;
14820 int ecode2 = 0 ;
14821 int val3 ;
14822 int ecode3 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "row",(char *) "col", NULL
14828 };
14829
14830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14834 }
14835 arg1 = reinterpret_cast< wxGrid * >(argp1);
14836 ecode2 = SWIG_AsVal_int(obj1, &val2);
14837 if (!SWIG_IsOK(ecode2)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14839 }
14840 arg2 = static_cast< int >(val2);
14841 ecode3 = SWIG_AsVal_int(obj2, &val3);
14842 if (!SWIG_IsOK(ecode3)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14844 }
14845 arg3 = static_cast< int >(val3);
14846 {
14847 PyThreadState* __tstate = wxPyBeginAllowThreads();
14848 result = (arg1)->GetCellTextColour(arg2,arg3);
14849 wxPyEndAllowThreads(__tstate);
14850 if (PyErr_Occurred()) SWIG_fail;
14851 }
14852 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14853 return resultobj;
14854 fail:
14855 return NULL;
14856 }
14857
14858
14859 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14860 PyObject *resultobj = 0;
14861 wxGrid *arg1 = (wxGrid *) 0 ;
14862 wxFont result;
14863 void *argp1 = 0 ;
14864 int res1 = 0 ;
14865 PyObject *swig_obj[1] ;
14866
14867 if (!args) SWIG_fail;
14868 swig_obj[0] = args;
14869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14870 if (!SWIG_IsOK(res1)) {
14871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14872 }
14873 arg1 = reinterpret_cast< wxGrid * >(argp1);
14874 {
14875 PyThreadState* __tstate = wxPyBeginAllowThreads();
14876 result = (arg1)->GetDefaultCellFont();
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14888 PyObject *resultobj = 0;
14889 wxGrid *arg1 = (wxGrid *) 0 ;
14890 int arg2 ;
14891 int arg3 ;
14892 wxFont result;
14893 void *argp1 = 0 ;
14894 int res1 = 0 ;
14895 int val2 ;
14896 int ecode2 = 0 ;
14897 int val3 ;
14898 int ecode3 = 0 ;
14899 PyObject * obj0 = 0 ;
14900 PyObject * obj1 = 0 ;
14901 PyObject * obj2 = 0 ;
14902 char * kwnames[] = {
14903 (char *) "self",(char *) "row",(char *) "col", NULL
14904 };
14905
14906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14908 if (!SWIG_IsOK(res1)) {
14909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14910 }
14911 arg1 = reinterpret_cast< wxGrid * >(argp1);
14912 ecode2 = SWIG_AsVal_int(obj1, &val2);
14913 if (!SWIG_IsOK(ecode2)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
14915 }
14916 arg2 = static_cast< int >(val2);
14917 ecode3 = SWIG_AsVal_int(obj2, &val3);
14918 if (!SWIG_IsOK(ecode3)) {
14919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
14920 }
14921 arg3 = static_cast< int >(val3);
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = (arg1)->GetCellFont(arg2,arg3);
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14936 PyObject *resultobj = 0;
14937 wxGrid *arg1 = (wxGrid *) 0 ;
14938 int *arg2 = (int *) 0 ;
14939 int *arg3 = (int *) 0 ;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 int temp2 ;
14943 int res2 = SWIG_TMPOBJ ;
14944 int temp3 ;
14945 int res3 = SWIG_TMPOBJ ;
14946 PyObject *swig_obj[1] ;
14947
14948 arg2 = &temp2;
14949 arg3 = &temp3;
14950 if (!args) SWIG_fail;
14951 swig_obj[0] = args;
14952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14953 if (!SWIG_IsOK(res1)) {
14954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
14955 }
14956 arg1 = reinterpret_cast< wxGrid * >(argp1);
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 (arg1)->GetDefaultCellAlignment(arg2,arg3);
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 resultobj = SWIG_Py_Void();
14964 if (SWIG_IsTmpObj(res2)) {
14965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14966 } else {
14967 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14969 }
14970 if (SWIG_IsTmpObj(res3)) {
14971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
14972 } else {
14973 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14975 }
14976 return resultobj;
14977 fail:
14978 return NULL;
14979 }
14980
14981
14982 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14983 PyObject *resultobj = 0;
14984 wxGrid *arg1 = (wxGrid *) 0 ;
14985 int arg2 ;
14986 int arg3 ;
14987 int *arg4 = (int *) 0 ;
14988 int *arg5 = (int *) 0 ;
14989 void *argp1 = 0 ;
14990 int res1 = 0 ;
14991 int val2 ;
14992 int ecode2 = 0 ;
14993 int val3 ;
14994 int ecode3 = 0 ;
14995 int temp4 ;
14996 int res4 = SWIG_TMPOBJ ;
14997 int temp5 ;
14998 int res5 = SWIG_TMPOBJ ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 PyObject * obj2 = 0 ;
15002 char * kwnames[] = {
15003 (char *) "self",(char *) "row",(char *) "col", NULL
15004 };
15005
15006 arg4 = &temp4;
15007 arg5 = &temp5;
15008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15012 }
15013 arg1 = reinterpret_cast< wxGrid * >(argp1);
15014 ecode2 = SWIG_AsVal_int(obj1, &val2);
15015 if (!SWIG_IsOK(ecode2)) {
15016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15017 }
15018 arg2 = static_cast< int >(val2);
15019 ecode3 = SWIG_AsVal_int(obj2, &val3);
15020 if (!SWIG_IsOK(ecode3)) {
15021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15022 }
15023 arg3 = static_cast< int >(val3);
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 resultobj = SWIG_Py_Void();
15031 if (SWIG_IsTmpObj(res4)) {
15032 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15033 } else {
15034 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15035 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15036 }
15037 if (SWIG_IsTmpObj(res5)) {
15038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15039 } else {
15040 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15042 }
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15050 PyObject *resultobj = 0;
15051 wxGrid *arg1 = (wxGrid *) 0 ;
15052 bool result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 PyObject *swig_obj[1] ;
15056
15057 if (!args) SWIG_fail;
15058 swig_obj[0] = args;
15059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15062 }
15063 arg1 = reinterpret_cast< wxGrid * >(argp1);
15064 {
15065 PyThreadState* __tstate = wxPyBeginAllowThreads();
15066 result = (bool)(arg1)->GetDefaultCellOverflow();
15067 wxPyEndAllowThreads(__tstate);
15068 if (PyErr_Occurred()) SWIG_fail;
15069 }
15070 {
15071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15072 }
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15080 PyObject *resultobj = 0;
15081 wxGrid *arg1 = (wxGrid *) 0 ;
15082 int arg2 ;
15083 int arg3 ;
15084 bool result;
15085 void *argp1 = 0 ;
15086 int res1 = 0 ;
15087 int val2 ;
15088 int ecode2 = 0 ;
15089 int val3 ;
15090 int ecode3 = 0 ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 PyObject * obj2 = 0 ;
15094 char * kwnames[] = {
15095 (char *) "self",(char *) "row",(char *) "col", NULL
15096 };
15097
15098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15100 if (!SWIG_IsOK(res1)) {
15101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15102 }
15103 arg1 = reinterpret_cast< wxGrid * >(argp1);
15104 ecode2 = SWIG_AsVal_int(obj1, &val2);
15105 if (!SWIG_IsOK(ecode2)) {
15106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15107 }
15108 arg2 = static_cast< int >(val2);
15109 ecode3 = SWIG_AsVal_int(obj2, &val3);
15110 if (!SWIG_IsOK(ecode3)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15112 }
15113 arg3 = static_cast< int >(val3);
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 {
15121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15122 }
15123 return resultobj;
15124 fail:
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15130 PyObject *resultobj = 0;
15131 wxGrid *arg1 = (wxGrid *) 0 ;
15132 int arg2 ;
15133 int arg3 ;
15134 int *arg4 = (int *) 0 ;
15135 int *arg5 = (int *) 0 ;
15136 void *argp1 = 0 ;
15137 int res1 = 0 ;
15138 int val2 ;
15139 int ecode2 = 0 ;
15140 int val3 ;
15141 int ecode3 = 0 ;
15142 int temp4 ;
15143 int res4 = SWIG_TMPOBJ ;
15144 int temp5 ;
15145 int res5 = SWIG_TMPOBJ ;
15146 PyObject * obj0 = 0 ;
15147 PyObject * obj1 = 0 ;
15148 PyObject * obj2 = 0 ;
15149 char * kwnames[] = {
15150 (char *) "self",(char *) "row",(char *) "col", NULL
15151 };
15152
15153 arg4 = &temp4;
15154 arg5 = &temp5;
15155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15159 }
15160 arg1 = reinterpret_cast< wxGrid * >(argp1);
15161 ecode2 = SWIG_AsVal_int(obj1, &val2);
15162 if (!SWIG_IsOK(ecode2)) {
15163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15164 }
15165 arg2 = static_cast< int >(val2);
15166 ecode3 = SWIG_AsVal_int(obj2, &val3);
15167 if (!SWIG_IsOK(ecode3)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15169 }
15170 arg3 = static_cast< int >(val3);
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_Py_Void();
15178 if (SWIG_IsTmpObj(res4)) {
15179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15180 } else {
15181 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15183 }
15184 if (SWIG_IsTmpObj(res5)) {
15185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15186 } else {
15187 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15189 }
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj = 0;
15198 wxGrid *arg1 = (wxGrid *) 0 ;
15199 int arg2 ;
15200 bool arg3 = (bool) false ;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 int val2 ;
15204 int ecode2 = 0 ;
15205 bool val3 ;
15206 int ecode3 = 0 ;
15207 PyObject * obj0 = 0 ;
15208 PyObject * obj1 = 0 ;
15209 PyObject * obj2 = 0 ;
15210 char * kwnames[] = {
15211 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15212 };
15213
15214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15216 if (!SWIG_IsOK(res1)) {
15217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15218 }
15219 arg1 = reinterpret_cast< wxGrid * >(argp1);
15220 ecode2 = SWIG_AsVal_int(obj1, &val2);
15221 if (!SWIG_IsOK(ecode2)) {
15222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15223 }
15224 arg2 = static_cast< int >(val2);
15225 if (obj2) {
15226 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15227 if (!SWIG_IsOK(ecode3)) {
15228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15229 }
15230 arg3 = static_cast< bool >(val3);
15231 }
15232 {
15233 PyThreadState* __tstate = wxPyBeginAllowThreads();
15234 (arg1)->SetDefaultRowSize(arg2,arg3);
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 resultobj = SWIG_Py_Void();
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15246 PyObject *resultobj = 0;
15247 wxGrid *arg1 = (wxGrid *) 0 ;
15248 int arg2 ;
15249 int arg3 ;
15250 void *argp1 = 0 ;
15251 int res1 = 0 ;
15252 int val2 ;
15253 int ecode2 = 0 ;
15254 int val3 ;
15255 int ecode3 = 0 ;
15256 PyObject * obj0 = 0 ;
15257 PyObject * obj1 = 0 ;
15258 PyObject * obj2 = 0 ;
15259 char * kwnames[] = {
15260 (char *) "self",(char *) "row",(char *) "height", NULL
15261 };
15262
15263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15267 }
15268 arg1 = reinterpret_cast< wxGrid * >(argp1);
15269 ecode2 = SWIG_AsVal_int(obj1, &val2);
15270 if (!SWIG_IsOK(ecode2)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15272 }
15273 arg2 = static_cast< int >(val2);
15274 ecode3 = SWIG_AsVal_int(obj2, &val3);
15275 if (!SWIG_IsOK(ecode3)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15277 }
15278 arg3 = static_cast< int >(val3);
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 (arg1)->SetRowSize(arg2,arg3);
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 resultobj = SWIG_Py_Void();
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj = 0;
15294 wxGrid *arg1 = (wxGrid *) 0 ;
15295 int arg2 ;
15296 bool arg3 = (bool) false ;
15297 void *argp1 = 0 ;
15298 int res1 = 0 ;
15299 int val2 ;
15300 int ecode2 = 0 ;
15301 bool val3 ;
15302 int ecode3 = 0 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 PyObject * obj2 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15314 }
15315 arg1 = reinterpret_cast< wxGrid * >(argp1);
15316 ecode2 = SWIG_AsVal_int(obj1, &val2);
15317 if (!SWIG_IsOK(ecode2)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15319 }
15320 arg2 = static_cast< int >(val2);
15321 if (obj2) {
15322 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15323 if (!SWIG_IsOK(ecode3)) {
15324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15325 }
15326 arg3 = static_cast< bool >(val3);
15327 }
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 (arg1)->SetDefaultColSize(arg2,arg3);
15331 wxPyEndAllowThreads(__tstate);
15332 if (PyErr_Occurred()) SWIG_fail;
15333 }
15334 resultobj = SWIG_Py_Void();
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15342 PyObject *resultobj = 0;
15343 wxGrid *arg1 = (wxGrid *) 0 ;
15344 int arg2 ;
15345 int arg3 ;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 int val2 ;
15349 int ecode2 = 0 ;
15350 int val3 ;
15351 int ecode3 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 PyObject * obj2 = 0 ;
15355 char * kwnames[] = {
15356 (char *) "self",(char *) "col",(char *) "width", NULL
15357 };
15358
15359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15363 }
15364 arg1 = reinterpret_cast< wxGrid * >(argp1);
15365 ecode2 = SWIG_AsVal_int(obj1, &val2);
15366 if (!SWIG_IsOK(ecode2)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15368 }
15369 arg2 = static_cast< int >(val2);
15370 ecode3 = SWIG_AsVal_int(obj2, &val3);
15371 if (!SWIG_IsOK(ecode3)) {
15372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15373 }
15374 arg3 = static_cast< int >(val3);
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 (arg1)->SetColSize(arg2,arg3);
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 resultobj = SWIG_Py_Void();
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15389 PyObject *resultobj = 0;
15390 wxGrid *arg1 = (wxGrid *) 0 ;
15391 int arg2 ;
15392 bool arg3 = (bool) true ;
15393 void *argp1 = 0 ;
15394 int res1 = 0 ;
15395 int val2 ;
15396 int ecode2 = 0 ;
15397 bool val3 ;
15398 int ecode3 = 0 ;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 PyObject * obj2 = 0 ;
15402 char * kwnames[] = {
15403 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15404 };
15405
15406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15408 if (!SWIG_IsOK(res1)) {
15409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15410 }
15411 arg1 = reinterpret_cast< wxGrid * >(argp1);
15412 ecode2 = SWIG_AsVal_int(obj1, &val2);
15413 if (!SWIG_IsOK(ecode2)) {
15414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15415 }
15416 arg2 = static_cast< int >(val2);
15417 if (obj2) {
15418 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15419 if (!SWIG_IsOK(ecode3)) {
15420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15421 }
15422 arg3 = static_cast< bool >(val3);
15423 }
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 (arg1)->AutoSizeColumn(arg2,arg3);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = SWIG_Py_Void();
15431 return resultobj;
15432 fail:
15433 return NULL;
15434 }
15435
15436
15437 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15438 PyObject *resultobj = 0;
15439 wxGrid *arg1 = (wxGrid *) 0 ;
15440 int arg2 ;
15441 bool arg3 = (bool) true ;
15442 void *argp1 = 0 ;
15443 int res1 = 0 ;
15444 int val2 ;
15445 int ecode2 = 0 ;
15446 bool val3 ;
15447 int ecode3 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 PyObject * obj2 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15459 }
15460 arg1 = reinterpret_cast< wxGrid * >(argp1);
15461 ecode2 = SWIG_AsVal_int(obj1, &val2);
15462 if (!SWIG_IsOK(ecode2)) {
15463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15464 }
15465 arg2 = static_cast< int >(val2);
15466 if (obj2) {
15467 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15468 if (!SWIG_IsOK(ecode3)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15470 }
15471 arg3 = static_cast< bool >(val3);
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 (arg1)->AutoSizeRow(arg2,arg3);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_Py_Void();
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxGrid *arg1 = (wxGrid *) 0 ;
15489 bool arg2 = (bool) true ;
15490 void *argp1 = 0 ;
15491 int res1 = 0 ;
15492 bool val2 ;
15493 int ecode2 = 0 ;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "setAsMin", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15504 }
15505 arg1 = reinterpret_cast< wxGrid * >(argp1);
15506 if (obj1) {
15507 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15508 if (!SWIG_IsOK(ecode2)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15510 }
15511 arg2 = static_cast< bool >(val2);
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 (arg1)->AutoSizeColumns(arg2);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_Py_Void();
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15527 PyObject *resultobj = 0;
15528 wxGrid *arg1 = (wxGrid *) 0 ;
15529 bool arg2 = (bool) true ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 bool val2 ;
15533 int ecode2 = 0 ;
15534 PyObject * obj0 = 0 ;
15535 PyObject * obj1 = 0 ;
15536 char * kwnames[] = {
15537 (char *) "self",(char *) "setAsMin", NULL
15538 };
15539
15540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15542 if (!SWIG_IsOK(res1)) {
15543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15544 }
15545 arg1 = reinterpret_cast< wxGrid * >(argp1);
15546 if (obj1) {
15547 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15548 if (!SWIG_IsOK(ecode2)) {
15549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15550 }
15551 arg2 = static_cast< bool >(val2);
15552 }
15553 {
15554 PyThreadState* __tstate = wxPyBeginAllowThreads();
15555 (arg1)->AutoSizeRows(arg2);
15556 wxPyEndAllowThreads(__tstate);
15557 if (PyErr_Occurred()) SWIG_fail;
15558 }
15559 resultobj = SWIG_Py_Void();
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15567 PyObject *resultobj = 0;
15568 wxGrid *arg1 = (wxGrid *) 0 ;
15569 void *argp1 = 0 ;
15570 int res1 = 0 ;
15571 PyObject *swig_obj[1] ;
15572
15573 if (!args) SWIG_fail;
15574 swig_obj[0] = args;
15575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15576 if (!SWIG_IsOK(res1)) {
15577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15578 }
15579 arg1 = reinterpret_cast< wxGrid * >(argp1);
15580 {
15581 PyThreadState* __tstate = wxPyBeginAllowThreads();
15582 (arg1)->AutoSize();
15583 wxPyEndAllowThreads(__tstate);
15584 if (PyErr_Occurred()) SWIG_fail;
15585 }
15586 resultobj = SWIG_Py_Void();
15587 return resultobj;
15588 fail:
15589 return NULL;
15590 }
15591
15592
15593 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15594 PyObject *resultobj = 0;
15595 wxGrid *arg1 = (wxGrid *) 0 ;
15596 int arg2 ;
15597 void *argp1 = 0 ;
15598 int res1 = 0 ;
15599 int val2 ;
15600 int ecode2 = 0 ;
15601 PyObject * obj0 = 0 ;
15602 PyObject * obj1 = 0 ;
15603 char * kwnames[] = {
15604 (char *) "self",(char *) "row", NULL
15605 };
15606
15607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15609 if (!SWIG_IsOK(res1)) {
15610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15611 }
15612 arg1 = reinterpret_cast< wxGrid * >(argp1);
15613 ecode2 = SWIG_AsVal_int(obj1, &val2);
15614 if (!SWIG_IsOK(ecode2)) {
15615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15616 }
15617 arg2 = static_cast< int >(val2);
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 (arg1)->AutoSizeRowLabelSize(arg2);
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 resultobj = SWIG_Py_Void();
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15632 PyObject *resultobj = 0;
15633 wxGrid *arg1 = (wxGrid *) 0 ;
15634 int arg2 ;
15635 void *argp1 = 0 ;
15636 int res1 = 0 ;
15637 int val2 ;
15638 int ecode2 = 0 ;
15639 PyObject * obj0 = 0 ;
15640 PyObject * obj1 = 0 ;
15641 char * kwnames[] = {
15642 (char *) "self",(char *) "col", NULL
15643 };
15644
15645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15647 if (!SWIG_IsOK(res1)) {
15648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15649 }
15650 arg1 = reinterpret_cast< wxGrid * >(argp1);
15651 ecode2 = SWIG_AsVal_int(obj1, &val2);
15652 if (!SWIG_IsOK(ecode2)) {
15653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15654 }
15655 arg2 = static_cast< int >(val2);
15656 {
15657 PyThreadState* __tstate = wxPyBeginAllowThreads();
15658 (arg1)->AutoSizeColLabelSize(arg2);
15659 wxPyEndAllowThreads(__tstate);
15660 if (PyErr_Occurred()) SWIG_fail;
15661 }
15662 resultobj = SWIG_Py_Void();
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj = 0;
15671 wxGrid *arg1 = (wxGrid *) 0 ;
15672 int arg2 ;
15673 int arg3 ;
15674 void *argp1 = 0 ;
15675 int res1 = 0 ;
15676 int val2 ;
15677 int ecode2 = 0 ;
15678 int val3 ;
15679 int ecode3 = 0 ;
15680 PyObject * obj0 = 0 ;
15681 PyObject * obj1 = 0 ;
15682 PyObject * obj2 = 0 ;
15683 char * kwnames[] = {
15684 (char *) "self",(char *) "col",(char *) "width", NULL
15685 };
15686
15687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15689 if (!SWIG_IsOK(res1)) {
15690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15691 }
15692 arg1 = reinterpret_cast< wxGrid * >(argp1);
15693 ecode2 = SWIG_AsVal_int(obj1, &val2);
15694 if (!SWIG_IsOK(ecode2)) {
15695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15696 }
15697 arg2 = static_cast< int >(val2);
15698 ecode3 = SWIG_AsVal_int(obj2, &val3);
15699 if (!SWIG_IsOK(ecode3)) {
15700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15701 }
15702 arg3 = static_cast< int >(val3);
15703 {
15704 PyThreadState* __tstate = wxPyBeginAllowThreads();
15705 (arg1)->SetColMinimalWidth(arg2,arg3);
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 resultobj = SWIG_Py_Void();
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15717 PyObject *resultobj = 0;
15718 wxGrid *arg1 = (wxGrid *) 0 ;
15719 int arg2 ;
15720 int arg3 ;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 int val2 ;
15724 int ecode2 = 0 ;
15725 int val3 ;
15726 int ecode3 = 0 ;
15727 PyObject * obj0 = 0 ;
15728 PyObject * obj1 = 0 ;
15729 PyObject * obj2 = 0 ;
15730 char * kwnames[] = {
15731 (char *) "self",(char *) "row",(char *) "width", NULL
15732 };
15733
15734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15738 }
15739 arg1 = reinterpret_cast< wxGrid * >(argp1);
15740 ecode2 = SWIG_AsVal_int(obj1, &val2);
15741 if (!SWIG_IsOK(ecode2)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
15743 }
15744 arg2 = static_cast< int >(val2);
15745 ecode3 = SWIG_AsVal_int(obj2, &val3);
15746 if (!SWIG_IsOK(ecode3)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
15748 }
15749 arg3 = static_cast< int >(val3);
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 (arg1)->SetRowMinimalHeight(arg2,arg3);
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 resultobj = SWIG_Py_Void();
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15764 PyObject *resultobj = 0;
15765 wxGrid *arg1 = (wxGrid *) 0 ;
15766 int arg2 ;
15767 void *argp1 = 0 ;
15768 int res1 = 0 ;
15769 int val2 ;
15770 int ecode2 = 0 ;
15771 PyObject * obj0 = 0 ;
15772 PyObject * obj1 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "self",(char *) "width", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
15778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15781 }
15782 arg1 = reinterpret_cast< wxGrid * >(argp1);
15783 ecode2 = SWIG_AsVal_int(obj1, &val2);
15784 if (!SWIG_IsOK(ecode2)) {
15785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
15786 }
15787 arg2 = static_cast< int >(val2);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 (arg1)->SetColMinimalAcceptableWidth(arg2);
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_Py_Void();
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15802 PyObject *resultobj = 0;
15803 wxGrid *arg1 = (wxGrid *) 0 ;
15804 int arg2 ;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 int val2 ;
15808 int ecode2 = 0 ;
15809 PyObject * obj0 = 0 ;
15810 PyObject * obj1 = 0 ;
15811 char * kwnames[] = {
15812 (char *) "self",(char *) "width", NULL
15813 };
15814
15815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
15816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15817 if (!SWIG_IsOK(res1)) {
15818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15819 }
15820 arg1 = reinterpret_cast< wxGrid * >(argp1);
15821 ecode2 = SWIG_AsVal_int(obj1, &val2);
15822 if (!SWIG_IsOK(ecode2)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
15824 }
15825 arg2 = static_cast< int >(val2);
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 (arg1)->SetRowMinimalAcceptableHeight(arg2);
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 resultobj = SWIG_Py_Void();
15833 return resultobj;
15834 fail:
15835 return NULL;
15836 }
15837
15838
15839 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15840 PyObject *resultobj = 0;
15841 wxGrid *arg1 = (wxGrid *) 0 ;
15842 int result;
15843 void *argp1 = 0 ;
15844 int res1 = 0 ;
15845 PyObject *swig_obj[1] ;
15846
15847 if (!args) SWIG_fail;
15848 swig_obj[0] = args;
15849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15850 if (!SWIG_IsOK(res1)) {
15851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
15852 }
15853 arg1 = reinterpret_cast< wxGrid * >(argp1);
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 resultobj = SWIG_From_int(static_cast< int >(result));
15861 return resultobj;
15862 fail:
15863 return NULL;
15864 }
15865
15866
15867 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15868 PyObject *resultobj = 0;
15869 wxGrid *arg1 = (wxGrid *) 0 ;
15870 int result;
15871 void *argp1 = 0 ;
15872 int res1 = 0 ;
15873 PyObject *swig_obj[1] ;
15874
15875 if (!args) SWIG_fail;
15876 swig_obj[0] = args;
15877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15878 if (!SWIG_IsOK(res1)) {
15879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
15880 }
15881 arg1 = reinterpret_cast< wxGrid * >(argp1);
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_From_int(static_cast< int >(result));
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj = 0;
15897 wxGrid *arg1 = (wxGrid *) 0 ;
15898 wxColour *arg2 = 0 ;
15899 void *argp1 = 0 ;
15900 int res1 = 0 ;
15901 wxColour temp2 ;
15902 PyObject * obj0 = 0 ;
15903 PyObject * obj1 = 0 ;
15904 char * kwnames[] = {
15905 (char *) "self",(char *)"arg2", NULL
15906 };
15907
15908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
15909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15910 if (!SWIG_IsOK(res1)) {
15911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15912 }
15913 arg1 = reinterpret_cast< wxGrid * >(argp1);
15914 {
15915 arg2 = &temp2;
15916 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15917 }
15918 {
15919 PyThreadState* __tstate = wxPyBeginAllowThreads();
15920 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
15921 wxPyEndAllowThreads(__tstate);
15922 if (PyErr_Occurred()) SWIG_fail;
15923 }
15924 resultobj = SWIG_Py_Void();
15925 return resultobj;
15926 fail:
15927 return NULL;
15928 }
15929
15930
15931 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15932 PyObject *resultobj = 0;
15933 wxGrid *arg1 = (wxGrid *) 0 ;
15934 int arg2 ;
15935 int arg3 ;
15936 wxColour *arg4 = 0 ;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 int val2 ;
15940 int ecode2 = 0 ;
15941 int val3 ;
15942 int ecode3 = 0 ;
15943 wxColour temp4 ;
15944 PyObject * obj0 = 0 ;
15945 PyObject * obj1 = 0 ;
15946 PyObject * obj2 = 0 ;
15947 PyObject * obj3 = 0 ;
15948 char * kwnames[] = {
15949 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
15950 };
15951
15952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15956 }
15957 arg1 = reinterpret_cast< wxGrid * >(argp1);
15958 ecode2 = SWIG_AsVal_int(obj1, &val2);
15959 if (!SWIG_IsOK(ecode2)) {
15960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15961 }
15962 arg2 = static_cast< int >(val2);
15963 ecode3 = SWIG_AsVal_int(obj2, &val3);
15964 if (!SWIG_IsOK(ecode3)) {
15965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15966 }
15967 arg3 = static_cast< int >(val3);
15968 {
15969 arg4 = &temp4;
15970 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
15971 }
15972 {
15973 PyThreadState* __tstate = wxPyBeginAllowThreads();
15974 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
15975 wxPyEndAllowThreads(__tstate);
15976 if (PyErr_Occurred()) SWIG_fail;
15977 }
15978 resultobj = SWIG_Py_Void();
15979 return resultobj;
15980 fail:
15981 return NULL;
15982 }
15983
15984
15985 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15986 PyObject *resultobj = 0;
15987 wxGrid *arg1 = (wxGrid *) 0 ;
15988 wxColour *arg2 = 0 ;
15989 void *argp1 = 0 ;
15990 int res1 = 0 ;
15991 wxColour temp2 ;
15992 PyObject * obj0 = 0 ;
15993 PyObject * obj1 = 0 ;
15994 char * kwnames[] = {
15995 (char *) "self",(char *)"arg2", NULL
15996 };
15997
15998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
15999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16002 }
16003 arg1 = reinterpret_cast< wxGrid * >(argp1);
16004 {
16005 arg2 = &temp2;
16006 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 resultobj = SWIG_Py_Void();
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj = 0;
16023 wxGrid *arg1 = (wxGrid *) 0 ;
16024 int arg2 ;
16025 int arg3 ;
16026 wxColour *arg4 = 0 ;
16027 void *argp1 = 0 ;
16028 int res1 = 0 ;
16029 int val2 ;
16030 int ecode2 = 0 ;
16031 int val3 ;
16032 int ecode3 = 0 ;
16033 wxColour temp4 ;
16034 PyObject * obj0 = 0 ;
16035 PyObject * obj1 = 0 ;
16036 PyObject * obj2 = 0 ;
16037 PyObject * obj3 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16046 }
16047 arg1 = reinterpret_cast< wxGrid * >(argp1);
16048 ecode2 = SWIG_AsVal_int(obj1, &val2);
16049 if (!SWIG_IsOK(ecode2)) {
16050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16051 }
16052 arg2 = static_cast< int >(val2);
16053 ecode3 = SWIG_AsVal_int(obj2, &val3);
16054 if (!SWIG_IsOK(ecode3)) {
16055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16056 }
16057 arg3 = static_cast< int >(val3);
16058 {
16059 arg4 = &temp4;
16060 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16061 }
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 resultobj = SWIG_Py_Void();
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16076 PyObject *resultobj = 0;
16077 wxGrid *arg1 = (wxGrid *) 0 ;
16078 wxFont *arg2 = 0 ;
16079 void *argp1 = 0 ;
16080 int res1 = 0 ;
16081 void *argp2 = 0 ;
16082 int res2 = 0 ;
16083 PyObject * obj0 = 0 ;
16084 PyObject * obj1 = 0 ;
16085 char * kwnames[] = {
16086 (char *) "self",(char *)"arg2", NULL
16087 };
16088
16089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16091 if (!SWIG_IsOK(res1)) {
16092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16093 }
16094 arg1 = reinterpret_cast< wxGrid * >(argp1);
16095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16096 if (!SWIG_IsOK(res2)) {
16097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16098 }
16099 if (!argp2) {
16100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16101 }
16102 arg2 = reinterpret_cast< wxFont * >(argp2);
16103 {
16104 PyThreadState* __tstate = wxPyBeginAllowThreads();
16105 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16106 wxPyEndAllowThreads(__tstate);
16107 if (PyErr_Occurred()) SWIG_fail;
16108 }
16109 resultobj = SWIG_Py_Void();
16110 return resultobj;
16111 fail:
16112 return NULL;
16113 }
16114
16115
16116 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16117 PyObject *resultobj = 0;
16118 wxGrid *arg1 = (wxGrid *) 0 ;
16119 int arg2 ;
16120 int arg3 ;
16121 wxFont *arg4 = 0 ;
16122 void *argp1 = 0 ;
16123 int res1 = 0 ;
16124 int val2 ;
16125 int ecode2 = 0 ;
16126 int val3 ;
16127 int ecode3 = 0 ;
16128 void *argp4 = 0 ;
16129 int res4 = 0 ;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 PyObject * obj2 = 0 ;
16133 PyObject * obj3 = 0 ;
16134 char * kwnames[] = {
16135 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16136 };
16137
16138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16142 }
16143 arg1 = reinterpret_cast< wxGrid * >(argp1);
16144 ecode2 = SWIG_AsVal_int(obj1, &val2);
16145 if (!SWIG_IsOK(ecode2)) {
16146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16147 }
16148 arg2 = static_cast< int >(val2);
16149 ecode3 = SWIG_AsVal_int(obj2, &val3);
16150 if (!SWIG_IsOK(ecode3)) {
16151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16152 }
16153 arg3 = static_cast< int >(val3);
16154 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16155 if (!SWIG_IsOK(res4)) {
16156 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16157 }
16158 if (!argp4) {
16159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16160 }
16161 arg4 = reinterpret_cast< wxFont * >(argp4);
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16165 wxPyEndAllowThreads(__tstate);
16166 if (PyErr_Occurred()) SWIG_fail;
16167 }
16168 resultobj = SWIG_Py_Void();
16169 return resultobj;
16170 fail:
16171 return NULL;
16172 }
16173
16174
16175 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16176 PyObject *resultobj = 0;
16177 wxGrid *arg1 = (wxGrid *) 0 ;
16178 int arg2 ;
16179 int arg3 ;
16180 void *argp1 = 0 ;
16181 int res1 = 0 ;
16182 int val2 ;
16183 int ecode2 = 0 ;
16184 int val3 ;
16185 int ecode3 = 0 ;
16186 PyObject * obj0 = 0 ;
16187 PyObject * obj1 = 0 ;
16188 PyObject * obj2 = 0 ;
16189 char * kwnames[] = {
16190 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16191 };
16192
16193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16197 }
16198 arg1 = reinterpret_cast< wxGrid * >(argp1);
16199 ecode2 = SWIG_AsVal_int(obj1, &val2);
16200 if (!SWIG_IsOK(ecode2)) {
16201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16202 }
16203 arg2 = static_cast< int >(val2);
16204 ecode3 = SWIG_AsVal_int(obj2, &val3);
16205 if (!SWIG_IsOK(ecode3)) {
16206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16207 }
16208 arg3 = static_cast< int >(val3);
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 resultobj = SWIG_Py_Void();
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj = 0;
16224 wxGrid *arg1 = (wxGrid *) 0 ;
16225 int arg2 ;
16226 int arg3 ;
16227 int arg4 ;
16228 int arg5 ;
16229 void *argp1 = 0 ;
16230 int res1 = 0 ;
16231 int val2 ;
16232 int ecode2 = 0 ;
16233 int val3 ;
16234 int ecode3 = 0 ;
16235 int val4 ;
16236 int ecode4 = 0 ;
16237 int val5 ;
16238 int ecode5 = 0 ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 PyObject * obj2 = 0 ;
16242 PyObject * obj3 = 0 ;
16243 PyObject * obj4 = 0 ;
16244 char * kwnames[] = {
16245 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16246 };
16247
16248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16250 if (!SWIG_IsOK(res1)) {
16251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16252 }
16253 arg1 = reinterpret_cast< wxGrid * >(argp1);
16254 ecode2 = SWIG_AsVal_int(obj1, &val2);
16255 if (!SWIG_IsOK(ecode2)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16257 }
16258 arg2 = static_cast< int >(val2);
16259 ecode3 = SWIG_AsVal_int(obj2, &val3);
16260 if (!SWIG_IsOK(ecode3)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16262 }
16263 arg3 = static_cast< int >(val3);
16264 ecode4 = SWIG_AsVal_int(obj3, &val4);
16265 if (!SWIG_IsOK(ecode4)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16267 }
16268 arg4 = static_cast< int >(val4);
16269 ecode5 = SWIG_AsVal_int(obj4, &val5);
16270 if (!SWIG_IsOK(ecode5)) {
16271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16272 }
16273 arg5 = static_cast< int >(val5);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_Py_Void();
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxGrid *arg1 = (wxGrid *) 0 ;
16290 bool arg2 ;
16291 void *argp1 = 0 ;
16292 int res1 = 0 ;
16293 bool val2 ;
16294 int ecode2 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "allow", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16305 }
16306 arg1 = reinterpret_cast< wxGrid * >(argp1);
16307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16308 if (!SWIG_IsOK(ecode2)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16310 }
16311 arg2 = static_cast< bool >(val2);
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 (arg1)->SetDefaultCellOverflow(arg2);
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_Py_Void();
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxGrid *arg1 = (wxGrid *) 0 ;
16328 int arg2 ;
16329 int arg3 ;
16330 bool arg4 ;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 int val2 ;
16334 int ecode2 = 0 ;
16335 int val3 ;
16336 int ecode3 = 0 ;
16337 bool val4 ;
16338 int ecode4 = 0 ;
16339 PyObject * obj0 = 0 ;
16340 PyObject * obj1 = 0 ;
16341 PyObject * obj2 = 0 ;
16342 PyObject * obj3 = 0 ;
16343 char * kwnames[] = {
16344 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16345 };
16346
16347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16349 if (!SWIG_IsOK(res1)) {
16350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16351 }
16352 arg1 = reinterpret_cast< wxGrid * >(argp1);
16353 ecode2 = SWIG_AsVal_int(obj1, &val2);
16354 if (!SWIG_IsOK(ecode2)) {
16355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16356 }
16357 arg2 = static_cast< int >(val2);
16358 ecode3 = SWIG_AsVal_int(obj2, &val3);
16359 if (!SWIG_IsOK(ecode3)) {
16360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16361 }
16362 arg3 = static_cast< int >(val3);
16363 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16364 if (!SWIG_IsOK(ecode4)) {
16365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16366 }
16367 arg4 = static_cast< bool >(val4);
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16371 wxPyEndAllowThreads(__tstate);
16372 if (PyErr_Occurred()) SWIG_fail;
16373 }
16374 resultobj = SWIG_Py_Void();
16375 return resultobj;
16376 fail:
16377 return NULL;
16378 }
16379
16380
16381 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16382 PyObject *resultobj = 0;
16383 wxGrid *arg1 = (wxGrid *) 0 ;
16384 int arg2 ;
16385 int arg3 ;
16386 int arg4 ;
16387 int arg5 ;
16388 void *argp1 = 0 ;
16389 int res1 = 0 ;
16390 int val2 ;
16391 int ecode2 = 0 ;
16392 int val3 ;
16393 int ecode3 = 0 ;
16394 int val4 ;
16395 int ecode4 = 0 ;
16396 int val5 ;
16397 int ecode5 = 0 ;
16398 PyObject * obj0 = 0 ;
16399 PyObject * obj1 = 0 ;
16400 PyObject * obj2 = 0 ;
16401 PyObject * obj3 = 0 ;
16402 PyObject * obj4 = 0 ;
16403 char * kwnames[] = {
16404 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16405 };
16406
16407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16409 if (!SWIG_IsOK(res1)) {
16410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16411 }
16412 arg1 = reinterpret_cast< wxGrid * >(argp1);
16413 ecode2 = SWIG_AsVal_int(obj1, &val2);
16414 if (!SWIG_IsOK(ecode2)) {
16415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16416 }
16417 arg2 = static_cast< int >(val2);
16418 ecode3 = SWIG_AsVal_int(obj2, &val3);
16419 if (!SWIG_IsOK(ecode3)) {
16420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16421 }
16422 arg3 = static_cast< int >(val3);
16423 ecode4 = SWIG_AsVal_int(obj3, &val4);
16424 if (!SWIG_IsOK(ecode4)) {
16425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16426 }
16427 arg4 = static_cast< int >(val4);
16428 ecode5 = SWIG_AsVal_int(obj4, &val5);
16429 if (!SWIG_IsOK(ecode5)) {
16430 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16431 }
16432 arg5 = static_cast< int >(val5);
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 resultobj = SWIG_Py_Void();
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj = 0;
16448 wxGrid *arg1 = (wxGrid *) 0 ;
16449 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 void *argp2 = 0 ;
16453 int res2 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "self",(char *) "renderer", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16462 if (!SWIG_IsOK(res1)) {
16463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16464 }
16465 arg1 = reinterpret_cast< wxGrid * >(argp1);
16466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16467 if (!SWIG_IsOK(res2)) {
16468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16469 }
16470 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 (arg1)->SetDefaultRenderer(arg2);
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 resultobj = SWIG_Py_Void();
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxGrid *arg1 = (wxGrid *) 0 ;
16487 int arg2 ;
16488 int arg3 ;
16489 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 int val2 ;
16493 int ecode2 = 0 ;
16494 int val3 ;
16495 int ecode3 = 0 ;
16496 void *argp4 = 0 ;
16497 int res4 = 0 ;
16498 PyObject * obj0 = 0 ;
16499 PyObject * obj1 = 0 ;
16500 PyObject * obj2 = 0 ;
16501 PyObject * obj3 = 0 ;
16502 char * kwnames[] = {
16503 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16504 };
16505
16506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16508 if (!SWIG_IsOK(res1)) {
16509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16510 }
16511 arg1 = reinterpret_cast< wxGrid * >(argp1);
16512 ecode2 = SWIG_AsVal_int(obj1, &val2);
16513 if (!SWIG_IsOK(ecode2)) {
16514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16515 }
16516 arg2 = static_cast< int >(val2);
16517 ecode3 = SWIG_AsVal_int(obj2, &val3);
16518 if (!SWIG_IsOK(ecode3)) {
16519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16520 }
16521 arg3 = static_cast< int >(val3);
16522 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16523 if (!SWIG_IsOK(res4)) {
16524 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16525 }
16526 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 resultobj = SWIG_Py_Void();
16534 return resultobj;
16535 fail:
16536 return NULL;
16537 }
16538
16539
16540 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16541 PyObject *resultobj = 0;
16542 wxGrid *arg1 = (wxGrid *) 0 ;
16543 wxGridCellRenderer *result = 0 ;
16544 void *argp1 = 0 ;
16545 int res1 = 0 ;
16546 PyObject *swig_obj[1] ;
16547
16548 if (!args) SWIG_fail;
16549 swig_obj[0] = args;
16550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16551 if (!SWIG_IsOK(res1)) {
16552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16553 }
16554 arg1 = reinterpret_cast< wxGrid * >(argp1);
16555 {
16556 PyThreadState* __tstate = wxPyBeginAllowThreads();
16557 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 {
16562 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16563 }
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj = 0;
16572 wxGrid *arg1 = (wxGrid *) 0 ;
16573 int arg2 ;
16574 int arg3 ;
16575 wxGridCellRenderer *result = 0 ;
16576 void *argp1 = 0 ;
16577 int res1 = 0 ;
16578 int val2 ;
16579 int ecode2 = 0 ;
16580 int val3 ;
16581 int ecode3 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 PyObject * obj2 = 0 ;
16585 char * kwnames[] = {
16586 (char *) "self",(char *) "row",(char *) "col", NULL
16587 };
16588
16589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16591 if (!SWIG_IsOK(res1)) {
16592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16593 }
16594 arg1 = reinterpret_cast< wxGrid * >(argp1);
16595 ecode2 = SWIG_AsVal_int(obj1, &val2);
16596 if (!SWIG_IsOK(ecode2)) {
16597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16598 }
16599 arg2 = static_cast< int >(val2);
16600 ecode3 = SWIG_AsVal_int(obj2, &val3);
16601 if (!SWIG_IsOK(ecode3)) {
16602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16603 }
16604 arg3 = static_cast< int >(val3);
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 {
16612 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16613 }
16614 return resultobj;
16615 fail:
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16621 PyObject *resultobj = 0;
16622 wxGrid *arg1 = (wxGrid *) 0 ;
16623 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 void *argp2 = 0 ;
16627 int res2 = 0 ;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char * kwnames[] = {
16631 (char *) "self",(char *) "editor", NULL
16632 };
16633
16634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16638 }
16639 arg1 = reinterpret_cast< wxGrid * >(argp1);
16640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16641 if (!SWIG_IsOK(res2)) {
16642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16643 }
16644 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 (arg1)->SetDefaultEditor(arg2);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 resultobj = SWIG_Py_Void();
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj = 0;
16660 wxGrid *arg1 = (wxGrid *) 0 ;
16661 int arg2 ;
16662 int arg3 ;
16663 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16664 void *argp1 = 0 ;
16665 int res1 = 0 ;
16666 int val2 ;
16667 int ecode2 = 0 ;
16668 int val3 ;
16669 int ecode3 = 0 ;
16670 void *argp4 = 0 ;
16671 int res4 = 0 ;
16672 PyObject * obj0 = 0 ;
16673 PyObject * obj1 = 0 ;
16674 PyObject * obj2 = 0 ;
16675 PyObject * obj3 = 0 ;
16676 char * kwnames[] = {
16677 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16678 };
16679
16680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16684 }
16685 arg1 = reinterpret_cast< wxGrid * >(argp1);
16686 ecode2 = SWIG_AsVal_int(obj1, &val2);
16687 if (!SWIG_IsOK(ecode2)) {
16688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16689 }
16690 arg2 = static_cast< int >(val2);
16691 ecode3 = SWIG_AsVal_int(obj2, &val3);
16692 if (!SWIG_IsOK(ecode3)) {
16693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16694 }
16695 arg3 = static_cast< int >(val3);
16696 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16697 if (!SWIG_IsOK(res4)) {
16698 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16699 }
16700 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 (arg1)->SetCellEditor(arg2,arg3,arg4);
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 resultobj = SWIG_Py_Void();
16708 return resultobj;
16709 fail:
16710 return NULL;
16711 }
16712
16713
16714 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16715 PyObject *resultobj = 0;
16716 wxGrid *arg1 = (wxGrid *) 0 ;
16717 wxGridCellEditor *result = 0 ;
16718 void *argp1 = 0 ;
16719 int res1 = 0 ;
16720 PyObject *swig_obj[1] ;
16721
16722 if (!args) SWIG_fail;
16723 swig_obj[0] = args;
16724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16727 }
16728 arg1 = reinterpret_cast< wxGrid * >(argp1);
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 {
16736 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16737 }
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj = 0;
16746 wxGrid *arg1 = (wxGrid *) 0 ;
16747 int arg2 ;
16748 int arg3 ;
16749 wxGridCellEditor *result = 0 ;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 int val2 ;
16753 int ecode2 = 0 ;
16754 int val3 ;
16755 int ecode3 = 0 ;
16756 PyObject * obj0 = 0 ;
16757 PyObject * obj1 = 0 ;
16758 PyObject * obj2 = 0 ;
16759 char * kwnames[] = {
16760 (char *) "self",(char *) "row",(char *) "col", NULL
16761 };
16762
16763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16767 }
16768 arg1 = reinterpret_cast< wxGrid * >(argp1);
16769 ecode2 = SWIG_AsVal_int(obj1, &val2);
16770 if (!SWIG_IsOK(ecode2)) {
16771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
16772 }
16773 arg2 = static_cast< int >(val2);
16774 ecode3 = SWIG_AsVal_int(obj2, &val3);
16775 if (!SWIG_IsOK(ecode3)) {
16776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
16777 }
16778 arg3 = static_cast< int >(val3);
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
16782 wxPyEndAllowThreads(__tstate);
16783 if (PyErr_Occurred()) SWIG_fail;
16784 }
16785 {
16786 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16787 }
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj = 0;
16796 wxGrid *arg1 = (wxGrid *) 0 ;
16797 int arg2 ;
16798 int arg3 ;
16799 wxString result;
16800 void *argp1 = 0 ;
16801 int res1 = 0 ;
16802 int val2 ;
16803 int ecode2 = 0 ;
16804 int val3 ;
16805 int ecode3 = 0 ;
16806 PyObject * obj0 = 0 ;
16807 PyObject * obj1 = 0 ;
16808 PyObject * obj2 = 0 ;
16809 char * kwnames[] = {
16810 (char *) "self",(char *) "row",(char *) "col", NULL
16811 };
16812
16813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16815 if (!SWIG_IsOK(res1)) {
16816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16817 }
16818 arg1 = reinterpret_cast< wxGrid * >(argp1);
16819 ecode2 = SWIG_AsVal_int(obj1, &val2);
16820 if (!SWIG_IsOK(ecode2)) {
16821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
16822 }
16823 arg2 = static_cast< int >(val2);
16824 ecode3 = SWIG_AsVal_int(obj2, &val3);
16825 if (!SWIG_IsOK(ecode3)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
16827 }
16828 arg3 = static_cast< int >(val3);
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 result = (arg1)->GetCellValue(arg2,arg3);
16832 wxPyEndAllowThreads(__tstate);
16833 if (PyErr_Occurred()) SWIG_fail;
16834 }
16835 {
16836 #if wxUSE_UNICODE
16837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16838 #else
16839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16840 #endif
16841 }
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj = 0;
16850 wxGrid *arg1 = (wxGrid *) 0 ;
16851 int arg2 ;
16852 int arg3 ;
16853 wxString *arg4 = 0 ;
16854 void *argp1 = 0 ;
16855 int res1 = 0 ;
16856 int val2 ;
16857 int ecode2 = 0 ;
16858 int val3 ;
16859 int ecode3 = 0 ;
16860 bool temp4 = false ;
16861 PyObject * obj0 = 0 ;
16862 PyObject * obj1 = 0 ;
16863 PyObject * obj2 = 0 ;
16864 PyObject * obj3 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16873 }
16874 arg1 = reinterpret_cast< wxGrid * >(argp1);
16875 ecode2 = SWIG_AsVal_int(obj1, &val2);
16876 if (!SWIG_IsOK(ecode2)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
16878 }
16879 arg2 = static_cast< int >(val2);
16880 ecode3 = SWIG_AsVal_int(obj2, &val3);
16881 if (!SWIG_IsOK(ecode3)) {
16882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
16883 }
16884 arg3 = static_cast< int >(val3);
16885 {
16886 arg4 = wxString_in_helper(obj3);
16887 if (arg4 == NULL) SWIG_fail;
16888 temp4 = true;
16889 }
16890 {
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 resultobj = SWIG_Py_Void();
16897 {
16898 if (temp4)
16899 delete arg4;
16900 }
16901 return resultobj;
16902 fail:
16903 {
16904 if (temp4)
16905 delete arg4;
16906 }
16907 return NULL;
16908 }
16909
16910
16911 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16912 PyObject *resultobj = 0;
16913 wxGrid *arg1 = (wxGrid *) 0 ;
16914 int arg2 ;
16915 int arg3 ;
16916 bool result;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 int val2 ;
16920 int ecode2 = 0 ;
16921 int val3 ;
16922 int ecode3 = 0 ;
16923 PyObject * obj0 = 0 ;
16924 PyObject * obj1 = 0 ;
16925 PyObject * obj2 = 0 ;
16926 char * kwnames[] = {
16927 (char *) "self",(char *) "row",(char *) "col", NULL
16928 };
16929
16930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16932 if (!SWIG_IsOK(res1)) {
16933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
16934 }
16935 arg1 = reinterpret_cast< wxGrid * >(argp1);
16936 ecode2 = SWIG_AsVal_int(obj1, &val2);
16937 if (!SWIG_IsOK(ecode2)) {
16938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
16939 }
16940 arg2 = static_cast< int >(val2);
16941 ecode3 = SWIG_AsVal_int(obj2, &val3);
16942 if (!SWIG_IsOK(ecode3)) {
16943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
16944 }
16945 arg3 = static_cast< int >(val3);
16946 {
16947 PyThreadState* __tstate = wxPyBeginAllowThreads();
16948 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
16949 wxPyEndAllowThreads(__tstate);
16950 if (PyErr_Occurred()) SWIG_fail;
16951 }
16952 {
16953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16954 }
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16962 PyObject *resultobj = 0;
16963 wxGrid *arg1 = (wxGrid *) 0 ;
16964 int arg2 ;
16965 int arg3 ;
16966 bool arg4 = (bool) true ;
16967 void *argp1 = 0 ;
16968 int res1 = 0 ;
16969 int val2 ;
16970 int ecode2 = 0 ;
16971 int val3 ;
16972 int ecode3 = 0 ;
16973 bool val4 ;
16974 int ecode4 = 0 ;
16975 PyObject * obj0 = 0 ;
16976 PyObject * obj1 = 0 ;
16977 PyObject * obj2 = 0 ;
16978 PyObject * obj3 = 0 ;
16979 char * kwnames[] = {
16980 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
16981 };
16982
16983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16985 if (!SWIG_IsOK(res1)) {
16986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
16987 }
16988 arg1 = reinterpret_cast< wxGrid * >(argp1);
16989 ecode2 = SWIG_AsVal_int(obj1, &val2);
16990 if (!SWIG_IsOK(ecode2)) {
16991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
16992 }
16993 arg2 = static_cast< int >(val2);
16994 ecode3 = SWIG_AsVal_int(obj2, &val3);
16995 if (!SWIG_IsOK(ecode3)) {
16996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
16997 }
16998 arg3 = static_cast< int >(val3);
16999 if (obj3) {
17000 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17001 if (!SWIG_IsOK(ecode4)) {
17002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17003 }
17004 arg4 = static_cast< bool >(val4);
17005 }
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 (arg1)->SetReadOnly(arg2,arg3,arg4);
17009 wxPyEndAllowThreads(__tstate);
17010 if (PyErr_Occurred()) SWIG_fail;
17011 }
17012 resultobj = SWIG_Py_Void();
17013 return resultobj;
17014 fail:
17015 return NULL;
17016 }
17017
17018
17019 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17020 PyObject *resultobj = 0;
17021 wxGrid *arg1 = (wxGrid *) 0 ;
17022 int arg2 ;
17023 bool arg3 = (bool) false ;
17024 void *argp1 = 0 ;
17025 int res1 = 0 ;
17026 int val2 ;
17027 int ecode2 = 0 ;
17028 bool val3 ;
17029 int ecode3 = 0 ;
17030 PyObject * obj0 = 0 ;
17031 PyObject * obj1 = 0 ;
17032 PyObject * obj2 = 0 ;
17033 char * kwnames[] = {
17034 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17035 };
17036
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17041 }
17042 arg1 = reinterpret_cast< wxGrid * >(argp1);
17043 ecode2 = SWIG_AsVal_int(obj1, &val2);
17044 if (!SWIG_IsOK(ecode2)) {
17045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17046 }
17047 arg2 = static_cast< int >(val2);
17048 if (obj2) {
17049 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17050 if (!SWIG_IsOK(ecode3)) {
17051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17052 }
17053 arg3 = static_cast< bool >(val3);
17054 }
17055 {
17056 PyThreadState* __tstate = wxPyBeginAllowThreads();
17057 (arg1)->SelectRow(arg2,arg3);
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 resultobj = SWIG_Py_Void();
17062 return resultobj;
17063 fail:
17064 return NULL;
17065 }
17066
17067
17068 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj = 0;
17070 wxGrid *arg1 = (wxGrid *) 0 ;
17071 int arg2 ;
17072 bool arg3 = (bool) false ;
17073 void *argp1 = 0 ;
17074 int res1 = 0 ;
17075 int val2 ;
17076 int ecode2 = 0 ;
17077 bool val3 ;
17078 int ecode3 = 0 ;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 PyObject * obj2 = 0 ;
17082 char * kwnames[] = {
17083 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17084 };
17085
17086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17088 if (!SWIG_IsOK(res1)) {
17089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17090 }
17091 arg1 = reinterpret_cast< wxGrid * >(argp1);
17092 ecode2 = SWIG_AsVal_int(obj1, &val2);
17093 if (!SWIG_IsOK(ecode2)) {
17094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17095 }
17096 arg2 = static_cast< int >(val2);
17097 if (obj2) {
17098 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17099 if (!SWIG_IsOK(ecode3)) {
17100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17101 }
17102 arg3 = static_cast< bool >(val3);
17103 }
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 (arg1)->SelectCol(arg2,arg3);
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 resultobj = SWIG_Py_Void();
17111 return resultobj;
17112 fail:
17113 return NULL;
17114 }
17115
17116
17117 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17118 PyObject *resultobj = 0;
17119 wxGrid *arg1 = (wxGrid *) 0 ;
17120 int arg2 ;
17121 int arg3 ;
17122 int arg4 ;
17123 int arg5 ;
17124 bool arg6 = (bool) false ;
17125 void *argp1 = 0 ;
17126 int res1 = 0 ;
17127 int val2 ;
17128 int ecode2 = 0 ;
17129 int val3 ;
17130 int ecode3 = 0 ;
17131 int val4 ;
17132 int ecode4 = 0 ;
17133 int val5 ;
17134 int ecode5 = 0 ;
17135 bool val6 ;
17136 int ecode6 = 0 ;
17137 PyObject * obj0 = 0 ;
17138 PyObject * obj1 = 0 ;
17139 PyObject * obj2 = 0 ;
17140 PyObject * obj3 = 0 ;
17141 PyObject * obj4 = 0 ;
17142 PyObject * obj5 = 0 ;
17143 char * kwnames[] = {
17144 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17145 };
17146
17147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17149 if (!SWIG_IsOK(res1)) {
17150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17151 }
17152 arg1 = reinterpret_cast< wxGrid * >(argp1);
17153 ecode2 = SWIG_AsVal_int(obj1, &val2);
17154 if (!SWIG_IsOK(ecode2)) {
17155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17156 }
17157 arg2 = static_cast< int >(val2);
17158 ecode3 = SWIG_AsVal_int(obj2, &val3);
17159 if (!SWIG_IsOK(ecode3)) {
17160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17161 }
17162 arg3 = static_cast< int >(val3);
17163 ecode4 = SWIG_AsVal_int(obj3, &val4);
17164 if (!SWIG_IsOK(ecode4)) {
17165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17166 }
17167 arg4 = static_cast< int >(val4);
17168 ecode5 = SWIG_AsVal_int(obj4, &val5);
17169 if (!SWIG_IsOK(ecode5)) {
17170 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17171 }
17172 arg5 = static_cast< int >(val5);
17173 if (obj5) {
17174 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17175 if (!SWIG_IsOK(ecode6)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17177 }
17178 arg6 = static_cast< bool >(val6);
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_Py_Void();
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17194 PyObject *resultobj = 0;
17195 wxGrid *arg1 = (wxGrid *) 0 ;
17196 void *argp1 = 0 ;
17197 int res1 = 0 ;
17198 PyObject *swig_obj[1] ;
17199
17200 if (!args) SWIG_fail;
17201 swig_obj[0] = args;
17202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17203 if (!SWIG_IsOK(res1)) {
17204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17205 }
17206 arg1 = reinterpret_cast< wxGrid * >(argp1);
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 (arg1)->SelectAll();
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 resultobj = SWIG_Py_Void();
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17221 PyObject *resultobj = 0;
17222 wxGrid *arg1 = (wxGrid *) 0 ;
17223 bool result;
17224 void *argp1 = 0 ;
17225 int res1 = 0 ;
17226 PyObject *swig_obj[1] ;
17227
17228 if (!args) SWIG_fail;
17229 swig_obj[0] = args;
17230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17231 if (!SWIG_IsOK(res1)) {
17232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17233 }
17234 arg1 = reinterpret_cast< wxGrid * >(argp1);
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (bool)(arg1)->IsSelection();
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 {
17242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17243 }
17244 return resultobj;
17245 fail:
17246 return NULL;
17247 }
17248
17249
17250 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17251 PyObject *resultobj = 0;
17252 wxGrid *arg1 = (wxGrid *) 0 ;
17253 void *argp1 = 0 ;
17254 int res1 = 0 ;
17255 PyObject *swig_obj[1] ;
17256
17257 if (!args) SWIG_fail;
17258 swig_obj[0] = args;
17259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17260 if (!SWIG_IsOK(res1)) {
17261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17262 }
17263 arg1 = reinterpret_cast< wxGrid * >(argp1);
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 (arg1)->ClearSelection();
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_Py_Void();
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj = 0;
17279 wxGrid *arg1 = (wxGrid *) 0 ;
17280 int arg2 ;
17281 int arg3 ;
17282 bool result;
17283 void *argp1 = 0 ;
17284 int res1 = 0 ;
17285 int val2 ;
17286 int ecode2 = 0 ;
17287 int val3 ;
17288 int ecode3 = 0 ;
17289 PyObject * obj0 = 0 ;
17290 PyObject * obj1 = 0 ;
17291 PyObject * obj2 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "self",(char *) "row",(char *) "col", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17298 if (!SWIG_IsOK(res1)) {
17299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17300 }
17301 arg1 = reinterpret_cast< wxGrid * >(argp1);
17302 ecode2 = SWIG_AsVal_int(obj1, &val2);
17303 if (!SWIG_IsOK(ecode2)) {
17304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17305 }
17306 arg2 = static_cast< int >(val2);
17307 ecode3 = SWIG_AsVal_int(obj2, &val3);
17308 if (!SWIG_IsOK(ecode3)) {
17309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17310 }
17311 arg3 = static_cast< int >(val3);
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17320 }
17321 return resultobj;
17322 fail:
17323 return NULL;
17324 }
17325
17326
17327 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *resultobj = 0;
17329 wxGrid *arg1 = (wxGrid *) 0 ;
17330 wxGridCellCoordsArray result;
17331 void *argp1 = 0 ;
17332 int res1 = 0 ;
17333 PyObject *swig_obj[1] ;
17334
17335 if (!args) SWIG_fail;
17336 swig_obj[0] = args;
17337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17338 if (!SWIG_IsOK(res1)) {
17339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17340 }
17341 arg1 = reinterpret_cast< wxGrid * >(argp1);
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = ((wxGrid const *)arg1)->GetSelectedCells();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = wxGridCellCoordsArray_helper(result);
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 PyObject *resultobj = 0;
17359 wxGrid *arg1 = (wxGrid *) 0 ;
17360 wxGridCellCoordsArray result;
17361 void *argp1 = 0 ;
17362 int res1 = 0 ;
17363 PyObject *swig_obj[1] ;
17364
17365 if (!args) SWIG_fail;
17366 swig_obj[0] = args;
17367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17368 if (!SWIG_IsOK(res1)) {
17369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17370 }
17371 arg1 = reinterpret_cast< wxGrid * >(argp1);
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 {
17379 resultobj = wxGridCellCoordsArray_helper(result);
17380 }
17381 return resultobj;
17382 fail:
17383 return NULL;
17384 }
17385
17386
17387 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 PyObject *resultobj = 0;
17389 wxGrid *arg1 = (wxGrid *) 0 ;
17390 wxGridCellCoordsArray result;
17391 void *argp1 = 0 ;
17392 int res1 = 0 ;
17393 PyObject *swig_obj[1] ;
17394
17395 if (!args) SWIG_fail;
17396 swig_obj[0] = args;
17397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17398 if (!SWIG_IsOK(res1)) {
17399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17400 }
17401 arg1 = reinterpret_cast< wxGrid * >(argp1);
17402 {
17403 PyThreadState* __tstate = wxPyBeginAllowThreads();
17404 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 {
17409 resultobj = wxGridCellCoordsArray_helper(result);
17410 }
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17418 PyObject *resultobj = 0;
17419 wxGrid *arg1 = (wxGrid *) 0 ;
17420 wxArrayInt result;
17421 void *argp1 = 0 ;
17422 int res1 = 0 ;
17423 PyObject *swig_obj[1] ;
17424
17425 if (!args) SWIG_fail;
17426 swig_obj[0] = args;
17427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17430 }
17431 arg1 = reinterpret_cast< wxGrid * >(argp1);
17432 {
17433 PyThreadState* __tstate = wxPyBeginAllowThreads();
17434 result = ((wxGrid const *)arg1)->GetSelectedRows();
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 {
17439 resultobj = PyList_New(0);
17440 size_t idx;
17441 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17442 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17443 PyList_Append(resultobj, val);
17444 Py_DECREF(val);
17445 }
17446 }
17447 return resultobj;
17448 fail:
17449 return NULL;
17450 }
17451
17452
17453 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17454 PyObject *resultobj = 0;
17455 wxGrid *arg1 = (wxGrid *) 0 ;
17456 wxArrayInt result;
17457 void *argp1 = 0 ;
17458 int res1 = 0 ;
17459 PyObject *swig_obj[1] ;
17460
17461 if (!args) SWIG_fail;
17462 swig_obj[0] = args;
17463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17464 if (!SWIG_IsOK(res1)) {
17465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17466 }
17467 arg1 = reinterpret_cast< wxGrid * >(argp1);
17468 {
17469 PyThreadState* __tstate = wxPyBeginAllowThreads();
17470 result = ((wxGrid const *)arg1)->GetSelectedCols();
17471 wxPyEndAllowThreads(__tstate);
17472 if (PyErr_Occurred()) SWIG_fail;
17473 }
17474 {
17475 resultobj = PyList_New(0);
17476 size_t idx;
17477 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17478 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17479 PyList_Append(resultobj, val);
17480 Py_DECREF(val);
17481 }
17482 }
17483 return resultobj;
17484 fail:
17485 return NULL;
17486 }
17487
17488
17489 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17490 PyObject *resultobj = 0;
17491 wxGrid *arg1 = (wxGrid *) 0 ;
17492 int arg2 ;
17493 void *argp1 = 0 ;
17494 int res1 = 0 ;
17495 int val2 ;
17496 int ecode2 = 0 ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 char * kwnames[] = {
17500 (char *) "self",(char *) "row", NULL
17501 };
17502
17503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17505 if (!SWIG_IsOK(res1)) {
17506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17507 }
17508 arg1 = reinterpret_cast< wxGrid * >(argp1);
17509 ecode2 = SWIG_AsVal_int(obj1, &val2);
17510 if (!SWIG_IsOK(ecode2)) {
17511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17512 }
17513 arg2 = static_cast< int >(val2);
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 (arg1)->DeselectRow(arg2);
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_Py_Void();
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = 0;
17529 wxGrid *arg1 = (wxGrid *) 0 ;
17530 int arg2 ;
17531 void *argp1 = 0 ;
17532 int res1 = 0 ;
17533 int val2 ;
17534 int ecode2 = 0 ;
17535 PyObject * obj0 = 0 ;
17536 PyObject * obj1 = 0 ;
17537 char * kwnames[] = {
17538 (char *) "self",(char *) "col", NULL
17539 };
17540
17541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17543 if (!SWIG_IsOK(res1)) {
17544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17545 }
17546 arg1 = reinterpret_cast< wxGrid * >(argp1);
17547 ecode2 = SWIG_AsVal_int(obj1, &val2);
17548 if (!SWIG_IsOK(ecode2)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17550 }
17551 arg2 = static_cast< int >(val2);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 (arg1)->DeselectCol(arg2);
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 resultobj = SWIG_Py_Void();
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = 0;
17567 wxGrid *arg1 = (wxGrid *) 0 ;
17568 int arg2 ;
17569 int arg3 ;
17570 void *argp1 = 0 ;
17571 int res1 = 0 ;
17572 int val2 ;
17573 int ecode2 = 0 ;
17574 int val3 ;
17575 int ecode3 = 0 ;
17576 PyObject * obj0 = 0 ;
17577 PyObject * obj1 = 0 ;
17578 PyObject * obj2 = 0 ;
17579 char * kwnames[] = {
17580 (char *) "self",(char *) "row",(char *) "col", NULL
17581 };
17582
17583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17585 if (!SWIG_IsOK(res1)) {
17586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17587 }
17588 arg1 = reinterpret_cast< wxGrid * >(argp1);
17589 ecode2 = SWIG_AsVal_int(obj1, &val2);
17590 if (!SWIG_IsOK(ecode2)) {
17591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17592 }
17593 arg2 = static_cast< int >(val2);
17594 ecode3 = SWIG_AsVal_int(obj2, &val3);
17595 if (!SWIG_IsOK(ecode3)) {
17596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17597 }
17598 arg3 = static_cast< int >(val3);
17599 {
17600 PyThreadState* __tstate = wxPyBeginAllowThreads();
17601 (arg1)->DeselectCell(arg2,arg3);
17602 wxPyEndAllowThreads(__tstate);
17603 if (PyErr_Occurred()) SWIG_fail;
17604 }
17605 resultobj = SWIG_Py_Void();
17606 return resultobj;
17607 fail:
17608 return NULL;
17609 }
17610
17611
17612 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj = 0;
17614 wxGrid *arg1 = (wxGrid *) 0 ;
17615 wxGridCellCoords *arg2 = 0 ;
17616 wxGridCellCoords *arg3 = 0 ;
17617 wxRect result;
17618 void *argp1 = 0 ;
17619 int res1 = 0 ;
17620 wxGridCellCoords temp2 ;
17621 wxGridCellCoords temp3 ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 PyObject * obj2 = 0 ;
17625 char * kwnames[] = {
17626 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17627 };
17628
17629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17633 }
17634 arg1 = reinterpret_cast< wxGrid * >(argp1);
17635 {
17636 arg2 = &temp2;
17637 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17638 }
17639 {
17640 arg3 = &temp3;
17641 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17650 return resultobj;
17651 fail:
17652 return NULL;
17653 }
17654
17655
17656 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17657 PyObject *resultobj = 0;
17658 wxGrid *arg1 = (wxGrid *) 0 ;
17659 wxColour result;
17660 void *argp1 = 0 ;
17661 int res1 = 0 ;
17662 PyObject *swig_obj[1] ;
17663
17664 if (!args) SWIG_fail;
17665 swig_obj[0] = args;
17666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17667 if (!SWIG_IsOK(res1)) {
17668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17669 }
17670 arg1 = reinterpret_cast< wxGrid * >(argp1);
17671 {
17672 PyThreadState* __tstate = wxPyBeginAllowThreads();
17673 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17674 wxPyEndAllowThreads(__tstate);
17675 if (PyErr_Occurred()) SWIG_fail;
17676 }
17677 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17678 return resultobj;
17679 fail:
17680 return NULL;
17681 }
17682
17683
17684 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17685 PyObject *resultobj = 0;
17686 wxGrid *arg1 = (wxGrid *) 0 ;
17687 wxColour result;
17688 void *argp1 = 0 ;
17689 int res1 = 0 ;
17690 PyObject *swig_obj[1] ;
17691
17692 if (!args) SWIG_fail;
17693 swig_obj[0] = args;
17694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17697 }
17698 arg1 = reinterpret_cast< wxGrid * >(argp1);
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17713 PyObject *resultobj = 0;
17714 wxGrid *arg1 = (wxGrid *) 0 ;
17715 wxColour *arg2 = 0 ;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 wxColour temp2 ;
17719 PyObject * obj0 = 0 ;
17720 PyObject * obj1 = 0 ;
17721 char * kwnames[] = {
17722 (char *) "self",(char *) "c", NULL
17723 };
17724
17725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17727 if (!SWIG_IsOK(res1)) {
17728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
17729 }
17730 arg1 = reinterpret_cast< wxGrid * >(argp1);
17731 {
17732 arg2 = &temp2;
17733 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17734 }
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 resultobj = SWIG_Py_Void();
17742 return resultobj;
17743 fail:
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxGrid *arg1 = (wxGrid *) 0 ;
17751 wxColour *arg2 = 0 ;
17752 void *argp1 = 0 ;
17753 int res1 = 0 ;
17754 wxColour temp2 ;
17755 PyObject * obj0 = 0 ;
17756 PyObject * obj1 = 0 ;
17757 char * kwnames[] = {
17758 (char *) "self",(char *) "c", NULL
17759 };
17760
17761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
17762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17763 if (!SWIG_IsOK(res1)) {
17764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
17765 }
17766 arg1 = reinterpret_cast< wxGrid * >(argp1);
17767 {
17768 arg2 = &temp2;
17769 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17770 }
17771 {
17772 PyThreadState* __tstate = wxPyBeginAllowThreads();
17773 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
17774 wxPyEndAllowThreads(__tstate);
17775 if (PyErr_Occurred()) SWIG_fail;
17776 }
17777 resultobj = SWIG_Py_Void();
17778 return resultobj;
17779 fail:
17780 return NULL;
17781 }
17782
17783
17784 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj = 0;
17786 wxGrid *arg1 = (wxGrid *) 0 ;
17787 wxString *arg2 = 0 ;
17788 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
17789 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17790 void *argp1 = 0 ;
17791 int res1 = 0 ;
17792 bool temp2 = false ;
17793 void *argp3 = 0 ;
17794 int res3 = 0 ;
17795 void *argp4 = 0 ;
17796 int res4 = 0 ;
17797 PyObject * obj0 = 0 ;
17798 PyObject * obj1 = 0 ;
17799 PyObject * obj2 = 0 ;
17800 PyObject * obj3 = 0 ;
17801 char * kwnames[] = {
17802 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
17803 };
17804
17805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17807 if (!SWIG_IsOK(res1)) {
17808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
17809 }
17810 arg1 = reinterpret_cast< wxGrid * >(argp1);
17811 {
17812 arg2 = wxString_in_helper(obj1);
17813 if (arg2 == NULL) SWIG_fail;
17814 temp2 = true;
17815 }
17816 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17817 if (!SWIG_IsOK(res3)) {
17818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
17819 }
17820 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
17821 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17822 if (!SWIG_IsOK(res4)) {
17823 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17824 }
17825 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 resultobj = SWIG_Py_Void();
17833 {
17834 if (temp2)
17835 delete arg2;
17836 }
17837 return resultobj;
17838 fail:
17839 {
17840 if (temp2)
17841 delete arg2;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj = 0;
17849 wxGrid *arg1 = (wxGrid *) 0 ;
17850 int arg2 ;
17851 int arg3 ;
17852 wxGridCellEditor *result = 0 ;
17853 void *argp1 = 0 ;
17854 int res1 = 0 ;
17855 int val2 ;
17856 int ecode2 = 0 ;
17857 int val3 ;
17858 int ecode3 = 0 ;
17859 PyObject * obj0 = 0 ;
17860 PyObject * obj1 = 0 ;
17861 PyObject * obj2 = 0 ;
17862 char * kwnames[] = {
17863 (char *) "self",(char *) "row",(char *) "col", NULL
17864 };
17865
17866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17868 if (!SWIG_IsOK(res1)) {
17869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17870 }
17871 arg1 = reinterpret_cast< wxGrid * >(argp1);
17872 ecode2 = SWIG_AsVal_int(obj1, &val2);
17873 if (!SWIG_IsOK(ecode2)) {
17874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
17875 }
17876 arg2 = static_cast< int >(val2);
17877 ecode3 = SWIG_AsVal_int(obj2, &val3);
17878 if (!SWIG_IsOK(ecode3)) {
17879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
17880 }
17881 arg3 = static_cast< int >(val3);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17890 }
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj = 0;
17899 wxGrid *arg1 = (wxGrid *) 0 ;
17900 int arg2 ;
17901 int arg3 ;
17902 wxGridCellRenderer *result = 0 ;
17903 void *argp1 = 0 ;
17904 int res1 = 0 ;
17905 int val2 ;
17906 int ecode2 = 0 ;
17907 int val3 ;
17908 int ecode3 = 0 ;
17909 PyObject * obj0 = 0 ;
17910 PyObject * obj1 = 0 ;
17911 PyObject * obj2 = 0 ;
17912 char * kwnames[] = {
17913 (char *) "self",(char *) "row",(char *) "col", NULL
17914 };
17915
17916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17918 if (!SWIG_IsOK(res1)) {
17919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17920 }
17921 arg1 = reinterpret_cast< wxGrid * >(argp1);
17922 ecode2 = SWIG_AsVal_int(obj1, &val2);
17923 if (!SWIG_IsOK(ecode2)) {
17924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
17925 }
17926 arg2 = static_cast< int >(val2);
17927 ecode3 = SWIG_AsVal_int(obj2, &val3);
17928 if (!SWIG_IsOK(ecode3)) {
17929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
17930 }
17931 arg3 = static_cast< int >(val3);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj = 0;
17949 wxGrid *arg1 = (wxGrid *) 0 ;
17950 wxString *arg2 = 0 ;
17951 wxGridCellEditor *result = 0 ;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 bool temp2 = false ;
17955 PyObject * obj0 = 0 ;
17956 PyObject * obj1 = 0 ;
17957 char * kwnames[] = {
17958 (char *) "self",(char *) "typeName", NULL
17959 };
17960
17961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
17962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17963 if (!SWIG_IsOK(res1)) {
17964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
17965 }
17966 arg1 = reinterpret_cast< wxGrid * >(argp1);
17967 {
17968 arg2 = wxString_in_helper(obj1);
17969 if (arg2 == NULL) SWIG_fail;
17970 temp2 = true;
17971 }
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 {
17979 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17980 }
17981 {
17982 if (temp2)
17983 delete arg2;
17984 }
17985 return resultobj;
17986 fail:
17987 {
17988 if (temp2)
17989 delete arg2;
17990 }
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj = 0;
17997 wxGrid *arg1 = (wxGrid *) 0 ;
17998 wxString *arg2 = 0 ;
17999 wxGridCellRenderer *result = 0 ;
18000 void *argp1 = 0 ;
18001 int res1 = 0 ;
18002 bool temp2 = false ;
18003 PyObject * obj0 = 0 ;
18004 PyObject * obj1 = 0 ;
18005 char * kwnames[] = {
18006 (char *) "self",(char *) "typeName", NULL
18007 };
18008
18009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18011 if (!SWIG_IsOK(res1)) {
18012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18013 }
18014 arg1 = reinterpret_cast< wxGrid * >(argp1);
18015 {
18016 arg2 = wxString_in_helper(obj1);
18017 if (arg2 == NULL) SWIG_fail;
18018 temp2 = true;
18019 }
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 {
18027 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18028 }
18029 {
18030 if (temp2)
18031 delete arg2;
18032 }
18033 return resultobj;
18034 fail:
18035 {
18036 if (temp2)
18037 delete arg2;
18038 }
18039 return NULL;
18040 }
18041
18042
18043 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18044 PyObject *resultobj = 0;
18045 wxGrid *arg1 = (wxGrid *) 0 ;
18046 int arg2 ;
18047 int arg3 ;
18048 void *argp1 = 0 ;
18049 int res1 = 0 ;
18050 int val2 ;
18051 int ecode2 = 0 ;
18052 int val3 ;
18053 int ecode3 = 0 ;
18054 PyObject * obj0 = 0 ;
18055 PyObject * obj1 = 0 ;
18056 PyObject * obj2 = 0 ;
18057 char * kwnames[] = {
18058 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18059 };
18060
18061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18063 if (!SWIG_IsOK(res1)) {
18064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18065 }
18066 arg1 = reinterpret_cast< wxGrid * >(argp1);
18067 ecode2 = SWIG_AsVal_int(obj1, &val2);
18068 if (!SWIG_IsOK(ecode2)) {
18069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18070 }
18071 arg2 = static_cast< int >(val2);
18072 ecode3 = SWIG_AsVal_int(obj2, &val3);
18073 if (!SWIG_IsOK(ecode3)) {
18074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18075 }
18076 arg3 = static_cast< int >(val3);
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 (arg1)->SetMargins(arg2,arg3);
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 resultobj = SWIG_Py_Void();
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *resultobj = 0;
18092 wxGrid *arg1 = (wxGrid *) 0 ;
18093 wxWindow *result = 0 ;
18094 void *argp1 = 0 ;
18095 int res1 = 0 ;
18096 PyObject *swig_obj[1] ;
18097
18098 if (!args) SWIG_fail;
18099 swig_obj[0] = args;
18100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18101 if (!SWIG_IsOK(res1)) {
18102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18103 }
18104 arg1 = reinterpret_cast< wxGrid * >(argp1);
18105 {
18106 PyThreadState* __tstate = wxPyBeginAllowThreads();
18107 result = (wxWindow *)(arg1)->GetGridWindow();
18108 wxPyEndAllowThreads(__tstate);
18109 if (PyErr_Occurred()) SWIG_fail;
18110 }
18111 {
18112 resultobj = wxPyMake_wxObject(result, 0);
18113 }
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18121 PyObject *resultobj = 0;
18122 wxGrid *arg1 = (wxGrid *) 0 ;
18123 wxWindow *result = 0 ;
18124 void *argp1 = 0 ;
18125 int res1 = 0 ;
18126 PyObject *swig_obj[1] ;
18127
18128 if (!args) SWIG_fail;
18129 swig_obj[0] = args;
18130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18131 if (!SWIG_IsOK(res1)) {
18132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18133 }
18134 arg1 = reinterpret_cast< wxGrid * >(argp1);
18135 {
18136 PyThreadState* __tstate = wxPyBeginAllowThreads();
18137 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18138 wxPyEndAllowThreads(__tstate);
18139 if (PyErr_Occurred()) SWIG_fail;
18140 }
18141 {
18142 resultobj = wxPyMake_wxObject(result, 0);
18143 }
18144 return resultobj;
18145 fail:
18146 return NULL;
18147 }
18148
18149
18150 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxGrid *arg1 = (wxGrid *) 0 ;
18153 wxWindow *result = 0 ;
18154 void *argp1 = 0 ;
18155 int res1 = 0 ;
18156 PyObject *swig_obj[1] ;
18157
18158 if (!args) SWIG_fail;
18159 swig_obj[0] = args;
18160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18161 if (!SWIG_IsOK(res1)) {
18162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18163 }
18164 arg1 = reinterpret_cast< wxGrid * >(argp1);
18165 {
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = wxPyMake_wxObject(result, 0);
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *resultobj = 0;
18182 wxGrid *arg1 = (wxGrid *) 0 ;
18183 wxWindow *result = 0 ;
18184 void *argp1 = 0 ;
18185 int res1 = 0 ;
18186 PyObject *swig_obj[1] ;
18187
18188 if (!args) SWIG_fail;
18189 swig_obj[0] = args;
18190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18191 if (!SWIG_IsOK(res1)) {
18192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18193 }
18194 arg1 = reinterpret_cast< wxGrid * >(argp1);
18195 {
18196 PyThreadState* __tstate = wxPyBeginAllowThreads();
18197 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18198 wxPyEndAllowThreads(__tstate);
18199 if (PyErr_Occurred()) SWIG_fail;
18200 }
18201 {
18202 resultobj = wxPyMake_wxObject(result, 0);
18203 }
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj = 0;
18212 wxGrid *arg1 = (wxGrid *) 0 ;
18213 int arg2 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 int val2 ;
18217 int ecode2 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char * kwnames[] = {
18221 (char *) "self",(char *) "x", NULL
18222 };
18223
18224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18228 }
18229 arg1 = reinterpret_cast< wxGrid * >(argp1);
18230 ecode2 = SWIG_AsVal_int(obj1, &val2);
18231 if (!SWIG_IsOK(ecode2)) {
18232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18233 }
18234 arg2 = static_cast< int >(val2);
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 (arg1)->SetScrollLineX(arg2);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 resultobj = SWIG_Py_Void();
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj = 0;
18250 wxGrid *arg1 = (wxGrid *) 0 ;
18251 int arg2 ;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 int val2 ;
18255 int ecode2 = 0 ;
18256 PyObject * obj0 = 0 ;
18257 PyObject * obj1 = 0 ;
18258 char * kwnames[] = {
18259 (char *) "self",(char *) "y", NULL
18260 };
18261
18262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18264 if (!SWIG_IsOK(res1)) {
18265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18266 }
18267 arg1 = reinterpret_cast< wxGrid * >(argp1);
18268 ecode2 = SWIG_AsVal_int(obj1, &val2);
18269 if (!SWIG_IsOK(ecode2)) {
18270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18271 }
18272 arg2 = static_cast< int >(val2);
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 (arg1)->SetScrollLineY(arg2);
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 resultobj = SWIG_Py_Void();
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18287 PyObject *resultobj = 0;
18288 wxGrid *arg1 = (wxGrid *) 0 ;
18289 int result;
18290 void *argp1 = 0 ;
18291 int res1 = 0 ;
18292 PyObject *swig_obj[1] ;
18293
18294 if (!args) SWIG_fail;
18295 swig_obj[0] = args;
18296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18297 if (!SWIG_IsOK(res1)) {
18298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18299 }
18300 arg1 = reinterpret_cast< wxGrid * >(argp1);
18301 {
18302 PyThreadState* __tstate = wxPyBeginAllowThreads();
18303 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18304 wxPyEndAllowThreads(__tstate);
18305 if (PyErr_Occurred()) SWIG_fail;
18306 }
18307 resultobj = SWIG_From_int(static_cast< int >(result));
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18315 PyObject *resultobj = 0;
18316 wxGrid *arg1 = (wxGrid *) 0 ;
18317 int result;
18318 void *argp1 = 0 ;
18319 int res1 = 0 ;
18320 PyObject *swig_obj[1] ;
18321
18322 if (!args) SWIG_fail;
18323 swig_obj[0] = args;
18324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18325 if (!SWIG_IsOK(res1)) {
18326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18327 }
18328 arg1 = reinterpret_cast< wxGrid * >(argp1);
18329 {
18330 PyThreadState* __tstate = wxPyBeginAllowThreads();
18331 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18332 wxPyEndAllowThreads(__tstate);
18333 if (PyErr_Occurred()) SWIG_fail;
18334 }
18335 resultobj = SWIG_From_int(static_cast< int >(result));
18336 return resultobj;
18337 fail:
18338 return NULL;
18339 }
18340
18341
18342 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18343 PyObject *resultobj = 0;
18344 wxGrid *arg1 = (wxGrid *) 0 ;
18345 int arg2 ;
18346 int result;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 int val2 ;
18350 int ecode2 = 0 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "x", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18361 }
18362 arg1 = reinterpret_cast< wxGrid * >(argp1);
18363 ecode2 = SWIG_AsVal_int(obj1, &val2);
18364 if (!SWIG_IsOK(ecode2)) {
18365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18366 }
18367 arg2 = static_cast< int >(val2);
18368 {
18369 PyThreadState* __tstate = wxPyBeginAllowThreads();
18370 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 resultobj = SWIG_From_int(static_cast< int >(result));
18375 return resultobj;
18376 fail:
18377 return NULL;
18378 }
18379
18380
18381 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18382 PyObject *resultobj = 0;
18383 wxGrid *arg1 = (wxGrid *) 0 ;
18384 int arg2 ;
18385 int result;
18386 void *argp1 = 0 ;
18387 int res1 = 0 ;
18388 int val2 ;
18389 int ecode2 = 0 ;
18390 PyObject * obj0 = 0 ;
18391 PyObject * obj1 = 0 ;
18392 char * kwnames[] = {
18393 (char *) "self",(char *) "y", NULL
18394 };
18395
18396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",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_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18400 }
18401 arg1 = reinterpret_cast< wxGrid * >(argp1);
18402 ecode2 = SWIG_AsVal_int(obj1, &val2);
18403 if (!SWIG_IsOK(ecode2)) {
18404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18405 }
18406 arg2 = static_cast< int >(val2);
18407 {
18408 PyThreadState* __tstate = wxPyBeginAllowThreads();
18409 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 resultobj = SWIG_From_int(static_cast< int >(result));
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj = 0;
18422 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18423 SwigValueWrapper<wxVisualAttributes > result;
18424 int val1 ;
18425 int ecode1 = 0 ;
18426 PyObject * obj0 = 0 ;
18427 char * kwnames[] = {
18428 (char *) "variant", NULL
18429 };
18430
18431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18432 if (obj0) {
18433 ecode1 = SWIG_AsVal_int(obj0, &val1);
18434 if (!SWIG_IsOK(ecode1)) {
18435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18436 }
18437 arg1 = static_cast< wxWindowVariant >(val1);
18438 }
18439 {
18440 if (!wxPyCheckForApp()) SWIG_fail;
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 result = wxGrid::GetClassDefaultAttributes(arg1);
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18454 PyObject *obj;
18455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18456 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18457 return SWIG_Py_Void();
18458 }
18459
18460 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18461 return SWIG_Python_InitShadowInstance(args);
18462 }
18463
18464 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj = 0;
18466 int arg1 ;
18467 wxEventType arg2 ;
18468 wxGrid *arg3 = (wxGrid *) 0 ;
18469 int arg4 = (int) -1 ;
18470 int arg5 = (int) -1 ;
18471 int arg6 = (int) -1 ;
18472 int arg7 = (int) -1 ;
18473 bool arg8 = (bool) true ;
18474 bool arg9 = (bool) false ;
18475 bool arg10 = (bool) false ;
18476 bool arg11 = (bool) false ;
18477 bool arg12 = (bool) false ;
18478 wxGridEvent *result = 0 ;
18479 int val1 ;
18480 int ecode1 = 0 ;
18481 int val2 ;
18482 int ecode2 = 0 ;
18483 void *argp3 = 0 ;
18484 int res3 = 0 ;
18485 int val4 ;
18486 int ecode4 = 0 ;
18487 int val5 ;
18488 int ecode5 = 0 ;
18489 int val6 ;
18490 int ecode6 = 0 ;
18491 int val7 ;
18492 int ecode7 = 0 ;
18493 bool val8 ;
18494 int ecode8 = 0 ;
18495 bool val9 ;
18496 int ecode9 = 0 ;
18497 bool val10 ;
18498 int ecode10 = 0 ;
18499 bool val11 ;
18500 int ecode11 = 0 ;
18501 bool val12 ;
18502 int ecode12 = 0 ;
18503 PyObject * obj0 = 0 ;
18504 PyObject * obj1 = 0 ;
18505 PyObject * obj2 = 0 ;
18506 PyObject * obj3 = 0 ;
18507 PyObject * obj4 = 0 ;
18508 PyObject * obj5 = 0 ;
18509 PyObject * obj6 = 0 ;
18510 PyObject * obj7 = 0 ;
18511 PyObject * obj8 = 0 ;
18512 PyObject * obj9 = 0 ;
18513 PyObject * obj10 = 0 ;
18514 PyObject * obj11 = 0 ;
18515 char * kwnames[] = {
18516 (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
18517 };
18518
18519 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;
18520 ecode1 = SWIG_AsVal_int(obj0, &val1);
18521 if (!SWIG_IsOK(ecode1)) {
18522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18523 }
18524 arg1 = static_cast< int >(val1);
18525 ecode2 = SWIG_AsVal_int(obj1, &val2);
18526 if (!SWIG_IsOK(ecode2)) {
18527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18528 }
18529 arg2 = static_cast< wxEventType >(val2);
18530 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18531 if (!SWIG_IsOK(res3)) {
18532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18533 }
18534 arg3 = reinterpret_cast< wxGrid * >(argp3);
18535 if (obj3) {
18536 ecode4 = SWIG_AsVal_int(obj3, &val4);
18537 if (!SWIG_IsOK(ecode4)) {
18538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18539 }
18540 arg4 = static_cast< int >(val4);
18541 }
18542 if (obj4) {
18543 ecode5 = SWIG_AsVal_int(obj4, &val5);
18544 if (!SWIG_IsOK(ecode5)) {
18545 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18546 }
18547 arg5 = static_cast< int >(val5);
18548 }
18549 if (obj5) {
18550 ecode6 = SWIG_AsVal_int(obj5, &val6);
18551 if (!SWIG_IsOK(ecode6)) {
18552 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18553 }
18554 arg6 = static_cast< int >(val6);
18555 }
18556 if (obj6) {
18557 ecode7 = SWIG_AsVal_int(obj6, &val7);
18558 if (!SWIG_IsOK(ecode7)) {
18559 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18560 }
18561 arg7 = static_cast< int >(val7);
18562 }
18563 if (obj7) {
18564 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18565 if (!SWIG_IsOK(ecode8)) {
18566 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18567 }
18568 arg8 = static_cast< bool >(val8);
18569 }
18570 if (obj8) {
18571 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18572 if (!SWIG_IsOK(ecode9)) {
18573 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18574 }
18575 arg9 = static_cast< bool >(val9);
18576 }
18577 if (obj9) {
18578 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18579 if (!SWIG_IsOK(ecode10)) {
18580 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18581 }
18582 arg10 = static_cast< bool >(val10);
18583 }
18584 if (obj10) {
18585 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18586 if (!SWIG_IsOK(ecode11)) {
18587 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18588 }
18589 arg11 = static_cast< bool >(val11);
18590 }
18591 if (obj11) {
18592 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18593 if (!SWIG_IsOK(ecode12)) {
18594 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18595 }
18596 arg12 = static_cast< bool >(val12);
18597 }
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18601 wxPyEndAllowThreads(__tstate);
18602 if (PyErr_Occurred()) SWIG_fail;
18603 }
18604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18605 return resultobj;
18606 fail:
18607 return NULL;
18608 }
18609
18610
18611 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18612 PyObject *resultobj = 0;
18613 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18614 int result;
18615 void *argp1 = 0 ;
18616 int res1 = 0 ;
18617 PyObject *swig_obj[1] ;
18618
18619 if (!args) SWIG_fail;
18620 swig_obj[0] = args;
18621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18622 if (!SWIG_IsOK(res1)) {
18623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18624 }
18625 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (int)(arg1)->GetRow();
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 resultobj = SWIG_From_int(static_cast< int >(result));
18633 return resultobj;
18634 fail:
18635 return NULL;
18636 }
18637
18638
18639 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18640 PyObject *resultobj = 0;
18641 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18642 int result;
18643 void *argp1 = 0 ;
18644 int res1 = 0 ;
18645 PyObject *swig_obj[1] ;
18646
18647 if (!args) SWIG_fail;
18648 swig_obj[0] = args;
18649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18650 if (!SWIG_IsOK(res1)) {
18651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18652 }
18653 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (int)(arg1)->GetCol();
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_From_int(static_cast< int >(result));
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18668 PyObject *resultobj = 0;
18669 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18670 wxPoint result;
18671 void *argp1 = 0 ;
18672 int res1 = 0 ;
18673 PyObject *swig_obj[1] ;
18674
18675 if (!args) SWIG_fail;
18676 swig_obj[0] = args;
18677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18678 if (!SWIG_IsOK(res1)) {
18679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18680 }
18681 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 result = (arg1)->GetPosition();
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18696 PyObject *resultobj = 0;
18697 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18698 bool result;
18699 void *argp1 = 0 ;
18700 int res1 = 0 ;
18701 PyObject *swig_obj[1] ;
18702
18703 if (!args) SWIG_fail;
18704 swig_obj[0] = args;
18705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18706 if (!SWIG_IsOK(res1)) {
18707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18708 }
18709 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = (bool)(arg1)->Selecting();
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 {
18717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18718 }
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18726 PyObject *resultobj = 0;
18727 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18728 bool result;
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_wxGridEvent, 0 | 0 );
18736 if (!SWIG_IsOK(res1)) {
18737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18738 }
18739 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (bool)(arg1)->ControlDown();
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 {
18747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18748 }
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18756 PyObject *resultobj = 0;
18757 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18758 bool result;
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_wxGridEvent, 0 | 0 );
18766 if (!SWIG_IsOK(res1)) {
18767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18768 }
18769 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18770 {
18771 PyThreadState* __tstate = wxPyBeginAllowThreads();
18772 result = (bool)(arg1)->MetaDown();
18773 wxPyEndAllowThreads(__tstate);
18774 if (PyErr_Occurred()) SWIG_fail;
18775 }
18776 {
18777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18778 }
18779 return resultobj;
18780 fail:
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18786 PyObject *resultobj = 0;
18787 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18788 bool result;
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_wxGridEvent, 0 | 0 );
18796 if (!SWIG_IsOK(res1)) {
18797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18798 }
18799 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18800 {
18801 PyThreadState* __tstate = wxPyBeginAllowThreads();
18802 result = (bool)(arg1)->ShiftDown();
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 {
18807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18808 }
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18818 bool result;
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_wxGridEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18828 }
18829 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (bool)(arg1)->AltDown();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18846 PyObject *obj;
18847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18848 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
18849 return SWIG_Py_Void();
18850 }
18851
18852 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18853 return SWIG_Python_InitShadowInstance(args);
18854 }
18855
18856 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18857 PyObject *resultobj = 0;
18858 int arg1 ;
18859 wxEventType arg2 ;
18860 wxGrid *arg3 = (wxGrid *) 0 ;
18861 int arg4 = (int) -1 ;
18862 int arg5 = (int) -1 ;
18863 int arg6 = (int) -1 ;
18864 bool arg7 = (bool) false ;
18865 bool arg8 = (bool) false ;
18866 bool arg9 = (bool) false ;
18867 bool arg10 = (bool) false ;
18868 wxGridSizeEvent *result = 0 ;
18869 int val1 ;
18870 int ecode1 = 0 ;
18871 int val2 ;
18872 int ecode2 = 0 ;
18873 void *argp3 = 0 ;
18874 int res3 = 0 ;
18875 int val4 ;
18876 int ecode4 = 0 ;
18877 int val5 ;
18878 int ecode5 = 0 ;
18879 int val6 ;
18880 int ecode6 = 0 ;
18881 bool val7 ;
18882 int ecode7 = 0 ;
18883 bool val8 ;
18884 int ecode8 = 0 ;
18885 bool val9 ;
18886 int ecode9 = 0 ;
18887 bool val10 ;
18888 int ecode10 = 0 ;
18889 PyObject * obj0 = 0 ;
18890 PyObject * obj1 = 0 ;
18891 PyObject * obj2 = 0 ;
18892 PyObject * obj3 = 0 ;
18893 PyObject * obj4 = 0 ;
18894 PyObject * obj5 = 0 ;
18895 PyObject * obj6 = 0 ;
18896 PyObject * obj7 = 0 ;
18897 PyObject * obj8 = 0 ;
18898 PyObject * obj9 = 0 ;
18899 char * kwnames[] = {
18900 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
18901 };
18902
18903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
18904 ecode1 = SWIG_AsVal_int(obj0, &val1);
18905 if (!SWIG_IsOK(ecode1)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
18907 }
18908 arg1 = static_cast< int >(val1);
18909 ecode2 = SWIG_AsVal_int(obj1, &val2);
18910 if (!SWIG_IsOK(ecode2)) {
18911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18912 }
18913 arg2 = static_cast< wxEventType >(val2);
18914 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18915 if (!SWIG_IsOK(res3)) {
18916 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18917 }
18918 arg3 = reinterpret_cast< wxGrid * >(argp3);
18919 if (obj3) {
18920 ecode4 = SWIG_AsVal_int(obj3, &val4);
18921 if (!SWIG_IsOK(ecode4)) {
18922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
18923 }
18924 arg4 = static_cast< int >(val4);
18925 }
18926 if (obj4) {
18927 ecode5 = SWIG_AsVal_int(obj4, &val5);
18928 if (!SWIG_IsOK(ecode5)) {
18929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
18930 }
18931 arg5 = static_cast< int >(val5);
18932 }
18933 if (obj5) {
18934 ecode6 = SWIG_AsVal_int(obj5, &val6);
18935 if (!SWIG_IsOK(ecode6)) {
18936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
18937 }
18938 arg6 = static_cast< int >(val6);
18939 }
18940 if (obj6) {
18941 ecode7 = SWIG_AsVal_bool(obj6, &val7);
18942 if (!SWIG_IsOK(ecode7)) {
18943 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
18944 }
18945 arg7 = static_cast< bool >(val7);
18946 }
18947 if (obj7) {
18948 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18949 if (!SWIG_IsOK(ecode8)) {
18950 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
18951 }
18952 arg8 = static_cast< bool >(val8);
18953 }
18954 if (obj8) {
18955 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18956 if (!SWIG_IsOK(ecode9)) {
18957 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
18958 }
18959 arg9 = static_cast< bool >(val9);
18960 }
18961 if (obj9) {
18962 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18963 if (!SWIG_IsOK(ecode10)) {
18964 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
18965 }
18966 arg10 = static_cast< bool >(val10);
18967 }
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
18975 return resultobj;
18976 fail:
18977 return NULL;
18978 }
18979
18980
18981 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18982 PyObject *resultobj = 0;
18983 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
18984 int result;
18985 void *argp1 = 0 ;
18986 int res1 = 0 ;
18987 PyObject *swig_obj[1] ;
18988
18989 if (!args) SWIG_fail;
18990 swig_obj[0] = args;
18991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
18992 if (!SWIG_IsOK(res1)) {
18993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
18994 }
18995 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
18996 {
18997 PyThreadState* __tstate = wxPyBeginAllowThreads();
18998 result = (int)(arg1)->GetRowOrCol();
18999 wxPyEndAllowThreads(__tstate);
19000 if (PyErr_Occurred()) SWIG_fail;
19001 }
19002 resultobj = SWIG_From_int(static_cast< int >(result));
19003 return resultobj;
19004 fail:
19005 return NULL;
19006 }
19007
19008
19009 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19010 PyObject *resultobj = 0;
19011 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19012 wxPoint result;
19013 void *argp1 = 0 ;
19014 int res1 = 0 ;
19015 PyObject *swig_obj[1] ;
19016
19017 if (!args) SWIG_fail;
19018 swig_obj[0] = args;
19019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19020 if (!SWIG_IsOK(res1)) {
19021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19022 }
19023 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19024 {
19025 PyThreadState* __tstate = wxPyBeginAllowThreads();
19026 result = (arg1)->GetPosition();
19027 wxPyEndAllowThreads(__tstate);
19028 if (PyErr_Occurred()) SWIG_fail;
19029 }
19030 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19038 PyObject *resultobj = 0;
19039 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19040 bool result;
19041 void *argp1 = 0 ;
19042 int res1 = 0 ;
19043 PyObject *swig_obj[1] ;
19044
19045 if (!args) SWIG_fail;
19046 swig_obj[0] = args;
19047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19050 }
19051 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (bool)(arg1)->ControlDown();
19055 wxPyEndAllowThreads(__tstate);
19056 if (PyErr_Occurred()) SWIG_fail;
19057 }
19058 {
19059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19060 }
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19070 bool result;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19080 }
19081 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)(arg1)->MetaDown();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 return resultobj;
19092 fail:
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19098 PyObject *resultobj = 0;
19099 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19100 bool result;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 PyObject *swig_obj[1] ;
19104
19105 if (!args) SWIG_fail;
19106 swig_obj[0] = args;
19107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19108 if (!SWIG_IsOK(res1)) {
19109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19110 }
19111 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 result = (bool)(arg1)->ShiftDown();
19115 wxPyEndAllowThreads(__tstate);
19116 if (PyErr_Occurred()) SWIG_fail;
19117 }
19118 {
19119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19120 }
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19130 bool result;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19140 }
19141 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (bool)(arg1)->AltDown();
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 {
19149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19150 }
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19158 PyObject *obj;
19159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19160 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19161 return SWIG_Py_Void();
19162 }
19163
19164 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165 return SWIG_Python_InitShadowInstance(args);
19166 }
19167
19168 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj = 0;
19170 int arg1 ;
19171 wxEventType arg2 ;
19172 wxGrid *arg3 = (wxGrid *) 0 ;
19173 wxGridCellCoords *arg4 = 0 ;
19174 wxGridCellCoords *arg5 = 0 ;
19175 bool arg6 = (bool) true ;
19176 bool arg7 = (bool) false ;
19177 bool arg8 = (bool) false ;
19178 bool arg9 = (bool) false ;
19179 bool arg10 = (bool) false ;
19180 wxGridRangeSelectEvent *result = 0 ;
19181 int val1 ;
19182 int ecode1 = 0 ;
19183 int val2 ;
19184 int ecode2 = 0 ;
19185 void *argp3 = 0 ;
19186 int res3 = 0 ;
19187 wxGridCellCoords temp4 ;
19188 wxGridCellCoords temp5 ;
19189 bool val6 ;
19190 int ecode6 = 0 ;
19191 bool val7 ;
19192 int ecode7 = 0 ;
19193 bool val8 ;
19194 int ecode8 = 0 ;
19195 bool val9 ;
19196 int ecode9 = 0 ;
19197 bool val10 ;
19198 int ecode10 = 0 ;
19199 PyObject * obj0 = 0 ;
19200 PyObject * obj1 = 0 ;
19201 PyObject * obj2 = 0 ;
19202 PyObject * obj3 = 0 ;
19203 PyObject * obj4 = 0 ;
19204 PyObject * obj5 = 0 ;
19205 PyObject * obj6 = 0 ;
19206 PyObject * obj7 = 0 ;
19207 PyObject * obj8 = 0 ;
19208 PyObject * obj9 = 0 ;
19209 char * kwnames[] = {
19210 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19211 };
19212
19213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19214 ecode1 = SWIG_AsVal_int(obj0, &val1);
19215 if (!SWIG_IsOK(ecode1)) {
19216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19217 }
19218 arg1 = static_cast< int >(val1);
19219 ecode2 = SWIG_AsVal_int(obj1, &val2);
19220 if (!SWIG_IsOK(ecode2)) {
19221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19222 }
19223 arg2 = static_cast< wxEventType >(val2);
19224 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19225 if (!SWIG_IsOK(res3)) {
19226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19227 }
19228 arg3 = reinterpret_cast< wxGrid * >(argp3);
19229 {
19230 arg4 = &temp4;
19231 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19232 }
19233 {
19234 arg5 = &temp5;
19235 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19236 }
19237 if (obj5) {
19238 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19239 if (!SWIG_IsOK(ecode6)) {
19240 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19241 }
19242 arg6 = static_cast< bool >(val6);
19243 }
19244 if (obj6) {
19245 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19246 if (!SWIG_IsOK(ecode7)) {
19247 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19248 }
19249 arg7 = static_cast< bool >(val7);
19250 }
19251 if (obj7) {
19252 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19253 if (!SWIG_IsOK(ecode8)) {
19254 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19255 }
19256 arg8 = static_cast< bool >(val8);
19257 }
19258 if (obj8) {
19259 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19260 if (!SWIG_IsOK(ecode9)) {
19261 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19262 }
19263 arg9 = static_cast< bool >(val9);
19264 }
19265 if (obj9) {
19266 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19267 if (!SWIG_IsOK(ecode10)) {
19268 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19269 }
19270 arg10 = static_cast< bool >(val10);
19271 }
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19286 PyObject *resultobj = 0;
19287 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19288 wxGridCellCoords result;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject *swig_obj[1] ;
19292
19293 if (!args) SWIG_fail;
19294 swig_obj[0] = args;
19295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19298 }
19299 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 result = (arg1)->GetTopLeftCoords();
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19314 PyObject *resultobj = 0;
19315 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19316 wxGridCellCoords result;
19317 void *argp1 = 0 ;
19318 int res1 = 0 ;
19319 PyObject *swig_obj[1] ;
19320
19321 if (!args) SWIG_fail;
19322 swig_obj[0] = args;
19323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19326 }
19327 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (arg1)->GetBottomRightCoords();
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342 PyObject *resultobj = 0;
19343 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19344 int result;
19345 void *argp1 = 0 ;
19346 int res1 = 0 ;
19347 PyObject *swig_obj[1] ;
19348
19349 if (!args) SWIG_fail;
19350 swig_obj[0] = args;
19351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19352 if (!SWIG_IsOK(res1)) {
19353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19354 }
19355 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = (int)(arg1)->GetTopRow();
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 resultobj = SWIG_From_int(static_cast< int >(result));
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19370 PyObject *resultobj = 0;
19371 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19372 int result;
19373 void *argp1 = 0 ;
19374 int res1 = 0 ;
19375 PyObject *swig_obj[1] ;
19376
19377 if (!args) SWIG_fail;
19378 swig_obj[0] = args;
19379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19380 if (!SWIG_IsOK(res1)) {
19381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19382 }
19383 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (int)(arg1)->GetBottomRow();
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 resultobj = SWIG_From_int(static_cast< int >(result));
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19398 PyObject *resultobj = 0;
19399 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19400 int result;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19410 }
19411 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = (int)(arg1)->GetLeftCol();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_From_int(static_cast< int >(result));
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19428 int result;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (int)(arg1)->GetRightCol();
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = SWIG_From_int(static_cast< int >(result));
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19454 PyObject *resultobj = 0;
19455 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19456 bool result;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 PyObject *swig_obj[1] ;
19460
19461 if (!args) SWIG_fail;
19462 swig_obj[0] = args;
19463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19464 if (!SWIG_IsOK(res1)) {
19465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19466 }
19467 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = (bool)(arg1)->Selecting();
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19484 PyObject *resultobj = 0;
19485 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19486 bool result;
19487 void *argp1 = 0 ;
19488 int res1 = 0 ;
19489 PyObject *swig_obj[1] ;
19490
19491 if (!args) SWIG_fail;
19492 swig_obj[0] = args;
19493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19494 if (!SWIG_IsOK(res1)) {
19495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19496 }
19497 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (bool)(arg1)->ControlDown();
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 {
19505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19506 }
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19514 PyObject *resultobj = 0;
19515 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19516 bool result;
19517 void *argp1 = 0 ;
19518 int res1 = 0 ;
19519 PyObject *swig_obj[1] ;
19520
19521 if (!args) SWIG_fail;
19522 swig_obj[0] = args;
19523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19524 if (!SWIG_IsOK(res1)) {
19525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19526 }
19527 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19528 {
19529 PyThreadState* __tstate = wxPyBeginAllowThreads();
19530 result = (bool)(arg1)->MetaDown();
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 {
19535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19536 }
19537 return resultobj;
19538 fail:
19539 return NULL;
19540 }
19541
19542
19543 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19544 PyObject *resultobj = 0;
19545 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19546 bool result;
19547 void *argp1 = 0 ;
19548 int res1 = 0 ;
19549 PyObject *swig_obj[1] ;
19550
19551 if (!args) SWIG_fail;
19552 swig_obj[0] = args;
19553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19554 if (!SWIG_IsOK(res1)) {
19555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19556 }
19557 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = (bool)(arg1)->ShiftDown();
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 {
19565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19566 }
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19574 PyObject *resultobj = 0;
19575 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19576 bool result;
19577 void *argp1 = 0 ;
19578 int res1 = 0 ;
19579 PyObject *swig_obj[1] ;
19580
19581 if (!args) SWIG_fail;
19582 swig_obj[0] = args;
19583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19584 if (!SWIG_IsOK(res1)) {
19585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19586 }
19587 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19588 {
19589 PyThreadState* __tstate = wxPyBeginAllowThreads();
19590 result = (bool)(arg1)->AltDown();
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 {
19595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19604 PyObject *obj;
19605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19606 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19607 return SWIG_Py_Void();
19608 }
19609
19610 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19611 return SWIG_Python_InitShadowInstance(args);
19612 }
19613
19614 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj = 0;
19616 int arg1 ;
19617 wxEventType arg2 ;
19618 wxObject *arg3 = (wxObject *) 0 ;
19619 int arg4 ;
19620 int arg5 ;
19621 wxControl *arg6 = (wxControl *) 0 ;
19622 wxGridEditorCreatedEvent *result = 0 ;
19623 int val1 ;
19624 int ecode1 = 0 ;
19625 int val2 ;
19626 int ecode2 = 0 ;
19627 void *argp3 = 0 ;
19628 int res3 = 0 ;
19629 int val4 ;
19630 int ecode4 = 0 ;
19631 int val5 ;
19632 int ecode5 = 0 ;
19633 void *argp6 = 0 ;
19634 int res6 = 0 ;
19635 PyObject * obj0 = 0 ;
19636 PyObject * obj1 = 0 ;
19637 PyObject * obj2 = 0 ;
19638 PyObject * obj3 = 0 ;
19639 PyObject * obj4 = 0 ;
19640 PyObject * obj5 = 0 ;
19641 char * kwnames[] = {
19642 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
19643 };
19644
19645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19646 ecode1 = SWIG_AsVal_int(obj0, &val1);
19647 if (!SWIG_IsOK(ecode1)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
19649 }
19650 arg1 = static_cast< int >(val1);
19651 ecode2 = SWIG_AsVal_int(obj1, &val2);
19652 if (!SWIG_IsOK(ecode2)) {
19653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19654 }
19655 arg2 = static_cast< wxEventType >(val2);
19656 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
19657 if (!SWIG_IsOK(res3)) {
19658 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
19659 }
19660 arg3 = reinterpret_cast< wxObject * >(argp3);
19661 ecode4 = SWIG_AsVal_int(obj3, &val4);
19662 if (!SWIG_IsOK(ecode4)) {
19663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
19664 }
19665 arg4 = static_cast< int >(val4);
19666 ecode5 = SWIG_AsVal_int(obj4, &val5);
19667 if (!SWIG_IsOK(ecode5)) {
19668 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
19669 }
19670 arg5 = static_cast< int >(val5);
19671 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
19672 if (!SWIG_IsOK(res6)) {
19673 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
19674 }
19675 arg6 = reinterpret_cast< wxControl * >(argp6);
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19690 PyObject *resultobj = 0;
19691 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19692 int result;
19693 void *argp1 = 0 ;
19694 int res1 = 0 ;
19695 PyObject *swig_obj[1] ;
19696
19697 if (!args) SWIG_fail;
19698 swig_obj[0] = args;
19699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19700 if (!SWIG_IsOK(res1)) {
19701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19702 }
19703 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19704 {
19705 PyThreadState* __tstate = wxPyBeginAllowThreads();
19706 result = (int)(arg1)->GetRow();
19707 wxPyEndAllowThreads(__tstate);
19708 if (PyErr_Occurred()) SWIG_fail;
19709 }
19710 resultobj = SWIG_From_int(static_cast< int >(result));
19711 return resultobj;
19712 fail:
19713 return NULL;
19714 }
19715
19716
19717 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19718 PyObject *resultobj = 0;
19719 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19720 int result;
19721 void *argp1 = 0 ;
19722 int res1 = 0 ;
19723 PyObject *swig_obj[1] ;
19724
19725 if (!args) SWIG_fail;
19726 swig_obj[0] = args;
19727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19728 if (!SWIG_IsOK(res1)) {
19729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19730 }
19731 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 result = (int)(arg1)->GetCol();
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_From_int(static_cast< int >(result));
19739 return resultobj;
19740 fail:
19741 return NULL;
19742 }
19743
19744
19745 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19746 PyObject *resultobj = 0;
19747 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19748 wxControl *result = 0 ;
19749 void *argp1 = 0 ;
19750 int res1 = 0 ;
19751 PyObject *swig_obj[1] ;
19752
19753 if (!args) SWIG_fail;
19754 swig_obj[0] = args;
19755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19756 if (!SWIG_IsOK(res1)) {
19757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19758 }
19759 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 result = (wxControl *)(arg1)->GetControl();
19763 wxPyEndAllowThreads(__tstate);
19764 if (PyErr_Occurred()) SWIG_fail;
19765 }
19766 {
19767 resultobj = wxPyMake_wxObject(result, 0);
19768 }
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19778 int arg2 ;
19779 void *argp1 = 0 ;
19780 int res1 = 0 ;
19781 int val2 ;
19782 int ecode2 = 0 ;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 char * kwnames[] = {
19786 (char *) "self",(char *) "row", NULL
19787 };
19788
19789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
19790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19791 if (!SWIG_IsOK(res1)) {
19792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19793 }
19794 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19795 ecode2 = SWIG_AsVal_int(obj1, &val2);
19796 if (!SWIG_IsOK(ecode2)) {
19797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
19798 }
19799 arg2 = static_cast< int >(val2);
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 (arg1)->SetRow(arg2);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 resultobj = SWIG_Py_Void();
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19814 PyObject *resultobj = 0;
19815 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19816 int arg2 ;
19817 void *argp1 = 0 ;
19818 int res1 = 0 ;
19819 int val2 ;
19820 int ecode2 = 0 ;
19821 PyObject * obj0 = 0 ;
19822 PyObject * obj1 = 0 ;
19823 char * kwnames[] = {
19824 (char *) "self",(char *) "col", NULL
19825 };
19826
19827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
19828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19829 if (!SWIG_IsOK(res1)) {
19830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19831 }
19832 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19833 ecode2 = SWIG_AsVal_int(obj1, &val2);
19834 if (!SWIG_IsOK(ecode2)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
19836 }
19837 arg2 = static_cast< int >(val2);
19838 {
19839 PyThreadState* __tstate = wxPyBeginAllowThreads();
19840 (arg1)->SetCol(arg2);
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 resultobj = SWIG_Py_Void();
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj = 0;
19853 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19854 wxControl *arg2 = (wxControl *) 0 ;
19855 void *argp1 = 0 ;
19856 int res1 = 0 ;
19857 void *argp2 = 0 ;
19858 int res2 = 0 ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char * kwnames[] = {
19862 (char *) "self",(char *) "ctrl", NULL
19863 };
19864
19865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
19866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19869 }
19870 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
19872 if (!SWIG_IsOK(res2)) {
19873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
19874 }
19875 arg2 = reinterpret_cast< wxControl * >(argp2);
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 (arg1)->SetControl(arg2);
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 resultobj = SWIG_Py_Void();
19883 return resultobj;
19884 fail:
19885 return NULL;
19886 }
19887
19888
19889 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19890 PyObject *obj;
19891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19892 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
19893 return SWIG_Py_Void();
19894 }
19895
19896 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19897 return SWIG_Python_InitShadowInstance(args);
19898 }
19899
19900 static PyMethodDef SwigMethods[] = {
19901 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
19902 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
19903 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
19904 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
19905 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
19906 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
19907 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
19908 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
19909 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
19910 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
19911 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
19912 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
19913 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
19914 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
19915 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
19916 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
19917 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
19918 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
19919 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
19920 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
19921 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
19922 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
19923 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
19924 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
19925 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
19926 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
19927 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
19928 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
19929 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
19930 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
19931 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
19932 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
19933 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
19934 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
19935 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
19936 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
19937 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
19938 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
19939 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
19940 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
19941 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
19942 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
19943 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
19944 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
19945 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
19946 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
19947 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
19948 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
19949 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
19950 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
19951 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
19952 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
19953 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
19954 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
19955 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
19956 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
19957 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
19958 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
19959 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
19960 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
19961 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
19962 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
19963 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
19964 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
19965 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
19966 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
19967 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
19968 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
19969 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
19970 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
19971 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
19972 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
19973 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
19974 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
19975 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
19976 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
19977 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
19978 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
19979 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
19980 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
19981 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
19982 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
19983 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
19984 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
19985 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
19986 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
19987 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
19988 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
19989 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
19990 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
19991 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
19992 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
19993 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
19994 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
19995 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
19996 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
19997 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
19998 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
19999 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20000 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20001 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20002 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20003 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20004 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20005 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20006 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20007 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20008 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20009 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20010 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20011 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20012 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20013 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20014 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20015 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20016 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20017 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20018 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20019 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20020 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20021 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20022 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20023 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20024 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20025 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20026 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20027 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20028 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20029 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20030 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20031 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20032 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20033 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20034 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20035 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20036 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20037 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20038 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20039 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20040 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20041 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20042 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20043 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20044 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20045 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20046 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20047 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20048 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20049 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20050 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20051 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20052 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20053 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20054 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20055 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20056 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20057 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20058 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20059 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20060 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20061 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20062 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20063 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20064 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20065 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20066 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20067 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20068 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20069 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20070 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20071 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20072 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20073 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20074 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20075 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20076 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20077 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20078 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20079 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20080 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20081 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20082 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20083 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20084 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20085 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20086 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20087 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20088 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20089 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20090 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20091 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20092 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20093 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20094 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20095 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20096 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20097 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20098 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20099 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20100 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20101 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20102 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20103 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20104 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20105 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20106 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20107 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20108 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20109 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20110 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20111 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20112 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20113 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20114 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20115 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20116 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20117 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20118 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20119 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20120 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20121 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20122 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20123 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20124 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20125 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20126 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20127 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20128 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20129 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20130 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20131 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20132 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20133 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20134 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20135 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20136 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20137 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20138 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20139 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20140 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20141 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20142 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20143 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20144 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20145 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20146 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20147 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20148 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20149 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20150 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20151 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20152 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20153 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20154 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20155 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20156 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20157 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20158 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20159 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20160 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20161 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20162 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20163 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20164 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20165 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20166 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20167 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20168 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20169 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20170 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20171 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20172 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20173 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20174 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20175 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20176 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20177 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20178 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20179 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20180 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20181 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20182 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20183 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20184 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20185 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20186 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20187 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20188 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20189 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20190 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20191 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20192 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20193 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20194 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20195 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20196 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20197 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20198 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20199 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20200 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20201 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20202 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20203 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20204 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20205 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20206 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20207 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20208 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20209 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20210 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20211 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20212 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20213 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20214 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20215 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20216 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20217 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20218 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20219 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20220 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20221 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20222 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20223 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20224 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20225 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20226 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20227 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20228 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20229 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20230 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20231 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20232 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20233 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20234 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20235 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20236 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20237 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20238 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20239 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20240 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20241 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20242 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20243 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20244 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20245 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20246 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20247 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20248 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20249 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20250 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20251 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20252 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20253 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20254 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20255 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20256 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20257 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20258 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20259 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20260 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20261 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20262 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20263 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20264 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20265 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20266 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20267 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20268 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20269 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20270 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20271 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20272 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20273 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20274 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20275 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20276 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20277 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20278 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20279 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20280 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20281 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20282 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20283 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20284 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20285 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20286 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20287 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20288 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20289 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20290 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20291 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20292 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20293 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20294 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20295 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20296 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20297 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20298 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20299 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20300 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20301 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20302 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20303 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20304 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20305 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20306 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20307 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20308 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20309 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20310 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20312 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20313 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20314 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20315 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20316 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20317 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20318 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20319 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20320 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20321 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20322 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20323 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20324 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20325 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20326 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20327 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20328 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20329 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20330 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20331 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20332 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20333 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20334 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20335 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20336 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20337 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20338 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20339 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20340 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20341 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20342 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20343 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20344 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20345 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20346 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20347 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20348 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20349 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20350 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20351 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20352 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20353 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20355 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20356 { NULL, NULL, 0, NULL }
20357 };
20358
20359
20360 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20361
20362 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20363 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20364 }
20365 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20366 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20367 }
20368 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20369 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20370 }
20371 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20372 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20373 }
20374 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20375 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20376 }
20377 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20378 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20379 }
20380 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20381 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20382 }
20383 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20384 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20385 }
20386 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20387 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20388 }
20389 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20390 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20391 }
20392 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20393 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20394 }
20395 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20396 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20397 }
20398 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20399 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20400 }
20401 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20402 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20403 }
20404 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20405 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20406 }
20407 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20408 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20409 }
20410 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20411 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20412 }
20413 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20414 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20415 }
20416 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20417 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20418 }
20419 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20420 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20421 }
20422 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20423 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20424 }
20425 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20426 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20427 }
20428 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20429 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20430 }
20431 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20432 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20433 }
20434 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20435 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20436 }
20437 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20438 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20439 }
20440 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20441 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20442 }
20443 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20444 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20445 }
20446 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20447 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20448 }
20449 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20450 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20451 }
20452 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20453 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20454 }
20455 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20456 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20457 }
20458 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20459 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20460 }
20461 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20462 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20463 }
20464 static void *_p_wxGridTo_p_wxPanel(void *x) {
20465 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20466 }
20467 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20468 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20469 }
20470 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20471 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20472 }
20473 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20474 return (void *)((wxPanel *) ((wxPyPanel *) x));
20475 }
20476 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20477 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20478 }
20479 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20480 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20481 }
20482 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20483 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20484 }
20485 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20486 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20487 }
20488 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20489 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20490 }
20491 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20492 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20493 }
20494 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20495 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20496 }
20497 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20498 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20499 }
20500 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20501 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20502 }
20503 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20504 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20505 }
20506 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20507 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20508 }
20509 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20510 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20511 }
20512 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20513 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20514 }
20515 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20516 return (void *)((wxWindow *) ((wxMenuBar *) x));
20517 }
20518 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20519 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20520 }
20521 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20522 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20523 }
20524 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20525 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20526 }
20527 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20528 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20529 }
20530 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20531 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20532 }
20533 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20534 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20535 }
20536 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20537 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20538 }
20539 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20540 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20541 }
20542 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20543 return (void *)((wxWindow *) ((wxPanel *) x));
20544 }
20545 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20546 return (void *)((wxWindow *) ((wxStatusBar *) x));
20547 }
20548 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20549 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20550 }
20551 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20552 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
20553 }
20554 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20555 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20556 }
20557 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20558 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20559 }
20560 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20561 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20562 }
20563 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20564 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20565 }
20566 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20567 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20568 }
20569 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20570 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20571 }
20572 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20573 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20574 }
20575 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20576 return (void *)((wxWindow *) ((wxSashWindow *) x));
20577 }
20578 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20579 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20580 }
20581 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20582 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20583 }
20584 static void *_p_wxControlTo_p_wxWindow(void *x) {
20585 return (void *)((wxWindow *) ((wxControl *) x));
20586 }
20587 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20588 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20589 }
20590 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20591 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20592 }
20593 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20594 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20595 }
20596 static void *_p_wxGridTo_p_wxWindow(void *x) {
20597 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20598 }
20599 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20600 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20601 }
20602 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20603 return (void *)((wxWindow *) ((wxPyWindow *) x));
20604 }
20605 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20606 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20607 }
20608 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20609 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20610 }
20611 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20612 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20613 }
20614 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20615 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20616 }
20617 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20618 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20619 }
20620 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20621 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20622 }
20623 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20624 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20625 }
20626 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20627 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20628 }
20629 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
20630 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
20631 }
20632 static void *_p_wxDialogTo_p_wxWindow(void *x) {
20633 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
20634 }
20635 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
20636 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
20637 }
20638 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
20639 return (void *)((wxControl *) ((wxControlWithItems *) x));
20640 }
20641 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
20642 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
20643 }
20644 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
20645 return (void *)((wxEvent *) ((wxMenuEvent *) x));
20646 }
20647 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
20648 return (void *)((wxEvent *) ((wxCloseEvent *) x));
20649 }
20650 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
20651 return (void *)((wxEvent *) ((wxMouseEvent *) x));
20652 }
20653 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
20654 return (void *)((wxEvent *) ((wxEraseEvent *) x));
20655 }
20656 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
20657 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
20658 }
20659 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
20660 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
20661 }
20662 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
20663 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
20664 }
20665 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
20666 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
20667 }
20668 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
20669 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
20670 }
20671 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
20672 return (void *)((wxEvent *) ((wxPyEvent *) x));
20673 }
20674 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
20675 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
20676 }
20677 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
20678 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
20679 }
20680 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
20681 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20682 }
20683 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
20684 return (void *)((wxEvent *) ((wxIdleEvent *) x));
20685 }
20686 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
20687 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
20688 }
20689 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
20690 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
20691 }
20692 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
20693 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
20694 }
20695 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
20696 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
20697 }
20698 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
20699 return (void *)((wxEvent *) ((wxActivateEvent *) x));
20700 }
20701 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
20702 return (void *)((wxEvent *) ((wxSizeEvent *) x));
20703 }
20704 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
20705 return (void *)((wxEvent *) ((wxMoveEvent *) x));
20706 }
20707 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
20708 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
20709 }
20710 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
20711 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
20712 }
20713 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
20714 return (void *)((wxEvent *) ((wxPaintEvent *) x));
20715 }
20716 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
20717 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
20718 }
20719 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
20720 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
20721 }
20722 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
20723 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
20724 }
20725 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
20726 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
20727 }
20728 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
20729 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20730 }
20731 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
20732 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
20733 }
20734 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
20735 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
20736 }
20737 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
20738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
20739 }
20740 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
20741 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
20742 }
20743 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
20744 return (void *)((wxEvent *) ((wxFocusEvent *) x));
20745 }
20746 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
20747 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
20748 }
20749 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
20750 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
20751 }
20752 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
20753 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20754 }
20755 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
20756 return (void *)((wxEvent *) ((wxShowEvent *) x));
20757 }
20758 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
20759 return (void *)((wxEvent *) ((wxCommandEvent *) x));
20760 }
20761 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
20762 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
20763 }
20764 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
20765 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
20766 }
20767 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
20768 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
20769 }
20770 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
20771 return (void *)((wxEvent *) ((wxKeyEvent *) x));
20772 }
20773 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
20774 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
20775 }
20776 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
20777 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
20778 }
20779 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
20780 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
20781 }
20782 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
20783 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20784 }
20785 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
20786 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20787 }
20788 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
20789 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20790 }
20791 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
20792 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
20793 }
20794 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
20795 return (void *)((wxObject *) ((wxSizerItem *) x));
20796 }
20797 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
20798 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
20799 }
20800 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
20801 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
20802 }
20803 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
20804 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
20805 }
20806 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
20807 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
20808 }
20809 static void *_p_wxSizerTo_p_wxObject(void *x) {
20810 return (void *)((wxObject *) ((wxSizer *) x));
20811 }
20812 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
20813 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
20814 }
20815 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
20816 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
20817 }
20818 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
20819 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
20820 }
20821 static void *_p_wxEventTo_p_wxObject(void *x) {
20822 return (void *)((wxObject *) ((wxEvent *) x));
20823 }
20824 static void *_p_wxFontDataTo_p_wxObject(void *x) {
20825 return (void *)((wxObject *) ((wxFontData *) x));
20826 }
20827 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
20828 return (void *)((wxObject *) ((wxPrintData *) x));
20829 }
20830 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
20831 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
20832 }
20833 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
20834 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
20835 }
20836 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
20837 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
20838 }
20839 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
20840 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
20841 }
20842 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
20843 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
20844 }
20845 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
20846 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
20847 }
20848 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
20849 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
20850 }
20851 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
20852 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
20853 }
20854 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
20855 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
20856 }
20857 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
20858 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
20859 }
20860 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
20861 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
20862 }
20863 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
20864 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20865 }
20866 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
20867 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
20868 }
20869 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
20870 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20871 }
20872 static void *_p_wxGridEventTo_p_wxObject(void *x) {
20873 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
20874 }
20875 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
20876 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
20877 }
20878 static void *_p_wxControlTo_p_wxObject(void *x) {
20879 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
20880 }
20881 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
20882 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
20883 }
20884 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
20885 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
20886 }
20887 static void *_p_wxFSFileTo_p_wxObject(void *x) {
20888 return (void *)((wxObject *) ((wxFSFile *) x));
20889 }
20890 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
20891 return (void *)((wxObject *) ((wxFindReplaceData *) x));
20892 }
20893 static void *_p_wxGridTo_p_wxObject(void *x) {
20894 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20895 }
20896 static void *_p_wxPySizerTo_p_wxObject(void *x) {
20897 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
20898 }
20899 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
20900 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20901 }
20902 static void *_p_wxColourDataTo_p_wxObject(void *x) {
20903 return (void *)((wxObject *) ((wxColourData *) x));
20904 }
20905 static void *_p_wxPyEventTo_p_wxObject(void *x) {
20906 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
20907 }
20908 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
20909 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
20910 }
20911 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
20912 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
20913 }
20914 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
20915 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20916 }
20917 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
20918 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20919 }
20920 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
20921 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20922 }
20923 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
20924 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20925 }
20926 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
20927 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20928 }
20929 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
20930 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20931 }
20932 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
20933 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20934 }
20935 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
20936 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20937 }
20938 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
20939 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20940 }
20941 static void *_p_wxShowEventTo_p_wxObject(void *x) {
20942 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
20943 }
20944 static void *_p_wxPrinterTo_p_wxObject(void *x) {
20945 return (void *)((wxObject *) ((wxPrinter *) x));
20946 }
20947 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
20948 return (void *)((wxObject *) ((wxMenuItem *) x));
20949 }
20950 static void *_p_wxDateEventTo_p_wxObject(void *x) {
20951 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
20952 }
20953 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
20954 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
20955 }
20956 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
20957 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
20958 }
20959 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
20960 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
20961 }
20962 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
20963 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
20964 }
20965 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
20966 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
20967 }
20968 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
20969 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
20970 }
20971 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
20972 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
20973 }
20974 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
20975 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
20976 }
20977 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
20978 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
20979 }
20980 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
20981 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
20982 }
20983 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
20984 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
20985 }
20986 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
20987 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
20988 }
20989 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
20990 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
20991 }
20992 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
20993 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
20994 }
20995 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
20996 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
20997 }
20998 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
20999 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21000 }
21001 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21002 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21003 }
21004 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21005 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21006 }
21007 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21008 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21009 }
21010 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21011 return (void *)((wxObject *) ((wxImageHandler *) x));
21012 }
21013 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21014 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21015 }
21016 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21017 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21018 }
21019 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21020 return (void *)((wxObject *) ((wxEvtHandler *) x));
21021 }
21022 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21023 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21024 }
21025 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21026 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21027 }
21028 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21029 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21030 }
21031 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21032 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21033 }
21034 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21035 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21036 }
21037 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21038 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21039 }
21040 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21041 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21042 }
21043 static void *_p_wxImageTo_p_wxObject(void *x) {
21044 return (void *)((wxObject *) ((wxImage *) x));
21045 }
21046 static void *_p_wxFrameTo_p_wxObject(void *x) {
21047 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21048 }
21049 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21050 return (void *)((wxObject *) ((wxPyPrintout *) x));
21051 }
21052 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21053 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21054 }
21055 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21056 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21057 }
21058 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21059 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21060 }
21061 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21062 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21063 }
21064 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21065 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21066 }
21067 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21068 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21069 }
21070 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21071 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21072 }
21073 static void *_p_wxWindowTo_p_wxObject(void *x) {
21074 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21075 }
21076 static void *_p_wxMenuTo_p_wxObject(void *x) {
21077 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21078 }
21079 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21081 }
21082 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21084 }
21085 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21087 }
21088 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21090 }
21091 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21093 }
21094 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21096 }
21097 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21099 }
21100 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21102 }
21103 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21105 }
21106 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21108 }
21109 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21111 }
21112 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21114 }
21115 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21117 }
21118 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21120 }
21121 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) ((wxPrintPreview *) x));
21123 }
21124 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21126 }
21127 static void *_p_wxPanelTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21129 }
21130 static void *_p_wxDialogTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21132 }
21133 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21135 }
21136 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21138 }
21139 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21141 }
21142 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21144 }
21145 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) ((wxPrintDialog *) x));
21147 }
21148 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) ((wxFileSystem *) x));
21150 }
21151 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21153 }
21154 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21156 }
21157 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21159 }
21160 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21162 }
21163 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21165 }
21166 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21168 }
21169 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) ((wxGridTableBase *) x));
21171 }
21172 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21174 }
21175 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21177 }
21178 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21180 }
21181 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21183 }
21184 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21186 }
21187 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21189 }
21190 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21192 }
21193 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21195 }
21196 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21198 }
21199 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21201 }
21202 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21204 }
21205 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21207 }
21208 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21210 }
21211 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21212 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21213 }
21214 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21215 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21216 }
21217 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21218 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21219 }
21220 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21221 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21222 }
21223 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21224 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21225 }
21226 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21227 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21228 }
21229 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21230 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21231 }
21232 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21233 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21234 }
21235 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21236 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21237 }
21238 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21239 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21240 }
21241 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21242 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21243 }
21244 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21245 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21246 }
21247 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21248 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21249 }
21250 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21251 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21252 }
21253 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21254 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21255 }
21256 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21257 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21258 }
21259 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21260 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21261 }
21262 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21263 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21264 }
21265 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21266 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21267 }
21268 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21269 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21270 }
21271 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21272 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21273 }
21274 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21275 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21276 }
21277 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21278 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21279 }
21280 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21281 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21282 }
21283 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21284 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21285 }
21286 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21287 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21288 }
21289 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21290 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21291 }
21292 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21293 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21294 }
21295 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21296 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21297 }
21298 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21299 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21300 }
21301 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21302 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21303 }
21304 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21305 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21306 }
21307 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21308 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21309 }
21310 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21311 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21312 }
21313 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21314 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21315 }
21316 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21317 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21318 }
21319 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21320 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21321 }
21322 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21323 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21324 }
21325 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21326 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21327 }
21328 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21329 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21330 }
21331 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21332 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21333 }
21334 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21335 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21336 }
21337 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21338 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21339 }
21340 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21341 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21342 }
21343 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21344 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21345 }
21346 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21347 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21348 }
21349 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21350 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21351 }
21352 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21353 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21354 }
21355 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21356 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21357 }
21358 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21359 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21360 }
21361 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21362 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21363 }
21364 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21365 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21366 }
21367 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21368 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21369 }
21370 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21371 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21372 }
21373 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21374 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21375 }
21376 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21377 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21378 }
21379 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21380 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21381 }
21382 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21383 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21384 }
21385 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21386 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21387 }
21388 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21389 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21390 }
21391 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21392 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21393 }
21394 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21395 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21396 }
21397 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21398 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21399 }
21400 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21401 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21402 }
21403 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21404 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21405 }
21406 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21407 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21408 }
21409 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21410 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21411 }
21412 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21413 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21414 }
21415 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21416 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21417 }
21418 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21419 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21420 }
21421 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21422 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21423 }
21424 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21425 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21426 }
21427 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21428 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21429 }
21430 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21431 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21432 }
21433 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21434 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21435 }
21436 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21437 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21438 }
21439 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21440 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21441 }
21442 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21443 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21444 }
21445 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21446 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21447 }
21448 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21449 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21450 }
21451 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21452 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21453 }
21454 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21455 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};
21456 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21457 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21458 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21459 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21460 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21461 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21462 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21463 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21464 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21465 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21466 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21467 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21468 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21469 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21470 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21471 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21472 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21473 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21474 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21475 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21476 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21477 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21478 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21479 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21480 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21481 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21482 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21483 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21484 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21485 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21486 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21487 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21488 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21489 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21490 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21491 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21492 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21493 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21494 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21495 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21496 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21497 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21498 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21499 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21500 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21501 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21502 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21503 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21504 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21505 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21506 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21507 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21508 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21509 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21510 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21511 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21512 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21513 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21514 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21515 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21516 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21517 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21518 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21519 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21520 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21521 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21522 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21523 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21524 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21525 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21526 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21527 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21528 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21529 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21530 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21531 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21532 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21533 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21534 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21535 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21536 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21537 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21538 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21539 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21540 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21541 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21542 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21543 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21544 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21545 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21546 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21547 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21548 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21549 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21550 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21551 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21552 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21553 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21554 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21555 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21556 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21557 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21558 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21559 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21560 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21561 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21562 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21563 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21564 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21565 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21566 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21567 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21568 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21569 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21570 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21571 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21572 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21573 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21574 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21575 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21576 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21577 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21578 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21579 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21580 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21581 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21582 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21583 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21584 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21585 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21586 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21587 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21588 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21589 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21590 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21591 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21592 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21593 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21594 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21595 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21596 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21597 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21598 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21599 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21600 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21601 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21602 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21603 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21604 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21605 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21606 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21607 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21608 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21609 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21610 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21611 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21612 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21613 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21614 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21615 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21616 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21617 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21618 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21619 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
21620 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
21621 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
21622 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
21623 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
21624 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
21625 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
21626 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
21627 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
21628 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
21629 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
21630 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
21631 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
21632 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
21633 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
21634 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
21635 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
21636 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
21637 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
21638 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
21639 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
21640
21641 static swig_type_info *swig_type_initial[] = {
21642 &_swigt__p_char,
21643 &_swigt__p_form_ops_t,
21644 &_swigt__p_int,
21645 &_swigt__p_long,
21646 &_swigt__p_unsigned_char,
21647 &_swigt__p_unsigned_int,
21648 &_swigt__p_unsigned_long,
21649 &_swigt__p_wxANIHandler,
21650 &_swigt__p_wxAcceleratorTable,
21651 &_swigt__p_wxActivateEvent,
21652 &_swigt__p_wxArrayString,
21653 &_swigt__p_wxBMPHandler,
21654 &_swigt__p_wxBoxSizer,
21655 &_swigt__p_wxCURHandler,
21656 &_swigt__p_wxCalculateLayoutEvent,
21657 &_swigt__p_wxChildFocusEvent,
21658 &_swigt__p_wxCloseEvent,
21659 &_swigt__p_wxColour,
21660 &_swigt__p_wxColourData,
21661 &_swigt__p_wxColourDialog,
21662 &_swigt__p_wxCommandEvent,
21663 &_swigt__p_wxContextMenuEvent,
21664 &_swigt__p_wxControl,
21665 &_swigt__p_wxControlWithItems,
21666 &_swigt__p_wxDC,
21667 &_swigt__p_wxDateEvent,
21668 &_swigt__p_wxDialog,
21669 &_swigt__p_wxDirDialog,
21670 &_swigt__p_wxDisplayChangedEvent,
21671 &_swigt__p_wxDropFilesEvent,
21672 &_swigt__p_wxDuplexMode,
21673 &_swigt__p_wxEraseEvent,
21674 &_swigt__p_wxEvent,
21675 &_swigt__p_wxEvtHandler,
21676 &_swigt__p_wxFSFile,
21677 &_swigt__p_wxFileDialog,
21678 &_swigt__p_wxFileSystem,
21679 &_swigt__p_wxFindDialogEvent,
21680 &_swigt__p_wxFindReplaceData,
21681 &_swigt__p_wxFindReplaceDialog,
21682 &_swigt__p_wxFlexGridSizer,
21683 &_swigt__p_wxFocusEvent,
21684 &_swigt__p_wxFont,
21685 &_swigt__p_wxFontData,
21686 &_swigt__p_wxFontDialog,
21687 &_swigt__p_wxFrame,
21688 &_swigt__p_wxGBSizerItem,
21689 &_swigt__p_wxGIFHandler,
21690 &_swigt__p_wxGrid,
21691 &_swigt__p_wxGridBagSizer,
21692 &_swigt__p_wxGridCellAttr,
21693 &_swigt__p_wxGridCellAttrProvider,
21694 &_swigt__p_wxGridCellAutoWrapStringEditor,
21695 &_swigt__p_wxGridCellAutoWrapStringRenderer,
21696 &_swigt__p_wxGridCellBoolEditor,
21697 &_swigt__p_wxGridCellBoolRenderer,
21698 &_swigt__p_wxGridCellChoiceEditor,
21699 &_swigt__p_wxGridCellCoords,
21700 &_swigt__p_wxGridCellDateTimeRenderer,
21701 &_swigt__p_wxGridCellEditor,
21702 &_swigt__p_wxGridCellEnumEditor,
21703 &_swigt__p_wxGridCellEnumRenderer,
21704 &_swigt__p_wxGridCellFloatEditor,
21705 &_swigt__p_wxGridCellFloatRenderer,
21706 &_swigt__p_wxGridCellNumberEditor,
21707 &_swigt__p_wxGridCellNumberRenderer,
21708 &_swigt__p_wxGridCellRenderer,
21709 &_swigt__p_wxGridCellStringRenderer,
21710 &_swigt__p_wxGridCellTextEditor,
21711 &_swigt__p_wxGridCellWorker,
21712 &_swigt__p_wxGridEditorCreatedEvent,
21713 &_swigt__p_wxGridEvent,
21714 &_swigt__p_wxGridRangeSelectEvent,
21715 &_swigt__p_wxGridSizeEvent,
21716 &_swigt__p_wxGridSizer,
21717 &_swigt__p_wxGridStringTable,
21718 &_swigt__p_wxGridTableBase,
21719 &_swigt__p_wxGridTableMessage,
21720 &_swigt__p_wxICOHandler,
21721 &_swigt__p_wxIconizeEvent,
21722 &_swigt__p_wxIdleEvent,
21723 &_swigt__p_wxImage,
21724 &_swigt__p_wxImageHandler,
21725 &_swigt__p_wxIndividualLayoutConstraint,
21726 &_swigt__p_wxInitDialogEvent,
21727 &_swigt__p_wxJPEGHandler,
21728 &_swigt__p_wxKeyEvent,
21729 &_swigt__p_wxLayoutAlgorithm,
21730 &_swigt__p_wxLayoutConstraints,
21731 &_swigt__p_wxMDIChildFrame,
21732 &_swigt__p_wxMDIClientWindow,
21733 &_swigt__p_wxMDIParentFrame,
21734 &_swigt__p_wxMaximizeEvent,
21735 &_swigt__p_wxMenu,
21736 &_swigt__p_wxMenuBar,
21737 &_swigt__p_wxMenuEvent,
21738 &_swigt__p_wxMenuItem,
21739 &_swigt__p_wxMessageDialog,
21740 &_swigt__p_wxMiniFrame,
21741 &_swigt__p_wxMouseCaptureChangedEvent,
21742 &_swigt__p_wxMouseEvent,
21743 &_swigt__p_wxMoveEvent,
21744 &_swigt__p_wxMultiChoiceDialog,
21745 &_swigt__p_wxNavigationKeyEvent,
21746 &_swigt__p_wxNcPaintEvent,
21747 &_swigt__p_wxNotifyEvent,
21748 &_swigt__p_wxObject,
21749 &_swigt__p_wxPCXHandler,
21750 &_swigt__p_wxPNGHandler,
21751 &_swigt__p_wxPNMHandler,
21752 &_swigt__p_wxPageSetupDialog,
21753 &_swigt__p_wxPageSetupDialogData,
21754 &_swigt__p_wxPaintEvent,
21755 &_swigt__p_wxPaletteChangedEvent,
21756 &_swigt__p_wxPanel,
21757 &_swigt__p_wxPaperSize,
21758 &_swigt__p_wxPasswordEntryDialog,
21759 &_swigt__p_wxPoint,
21760 &_swigt__p_wxPopupWindow,
21761 &_swigt__p_wxPreviewCanvas,
21762 &_swigt__p_wxPreviewControlBar,
21763 &_swigt__p_wxPreviewFrame,
21764 &_swigt__p_wxPrintData,
21765 &_swigt__p_wxPrintDialog,
21766 &_swigt__p_wxPrintDialogData,
21767 &_swigt__p_wxPrintPreview,
21768 &_swigt__p_wxPrinter,
21769 &_swigt__p_wxProgressDialog,
21770 &_swigt__p_wxPyApp,
21771 &_swigt__p_wxPyCommandEvent,
21772 &_swigt__p_wxPyEvent,
21773 &_swigt__p_wxPyGridCellAttrProvider,
21774 &_swigt__p_wxPyGridCellEditor,
21775 &_swigt__p_wxPyGridCellRenderer,
21776 &_swigt__p_wxPyGridTableBase,
21777 &_swigt__p_wxPyHtmlListBox,
21778 &_swigt__p_wxPyImageHandler,
21779 &_swigt__p_wxPyPanel,
21780 &_swigt__p_wxPyPopupTransientWindow,
21781 &_swigt__p_wxPyPreviewControlBar,
21782 &_swigt__p_wxPyPreviewFrame,
21783 &_swigt__p_wxPyPrintPreview,
21784 &_swigt__p_wxPyPrintout,
21785 &_swigt__p_wxPyScrolledWindow,
21786 &_swigt__p_wxPySizer,
21787 &_swigt__p_wxPyTaskBarIcon,
21788 &_swigt__p_wxPyVListBox,
21789 &_swigt__p_wxPyVScrolledWindow,
21790 &_swigt__p_wxPyValidator,
21791 &_swigt__p_wxPyWindow,
21792 &_swigt__p_wxQueryLayoutInfoEvent,
21793 &_swigt__p_wxQueryNewPaletteEvent,
21794 &_swigt__p_wxRect,
21795 &_swigt__p_wxSashEvent,
21796 &_swigt__p_wxSashLayoutWindow,
21797 &_swigt__p_wxSashWindow,
21798 &_swigt__p_wxScrollEvent,
21799 &_swigt__p_wxScrollWinEvent,
21800 &_swigt__p_wxScrolledWindow,
21801 &_swigt__p_wxSetCursorEvent,
21802 &_swigt__p_wxShowEvent,
21803 &_swigt__p_wxSingleChoiceDialog,
21804 &_swigt__p_wxSizeEvent,
21805 &_swigt__p_wxSizer,
21806 &_swigt__p_wxSizerItem,
21807 &_swigt__p_wxSplashScreen,
21808 &_swigt__p_wxSplashScreenWindow,
21809 &_swigt__p_wxSplitterEvent,
21810 &_swigt__p_wxSplitterWindow,
21811 &_swigt__p_wxStaticBoxSizer,
21812 &_swigt__p_wxStatusBar,
21813 &_swigt__p_wxStdDialogButtonSizer,
21814 &_swigt__p_wxString,
21815 &_swigt__p_wxSysColourChangedEvent,
21816 &_swigt__p_wxTIFFHandler,
21817 &_swigt__p_wxTaskBarIconEvent,
21818 &_swigt__p_wxTextEntryDialog,
21819 &_swigt__p_wxTipWindow,
21820 &_swigt__p_wxTopLevelWindow,
21821 &_swigt__p_wxUpdateUIEvent,
21822 &_swigt__p_wxValidator,
21823 &_swigt__p_wxVisualAttributes,
21824 &_swigt__p_wxWindow,
21825 &_swigt__p_wxWindowCreateEvent,
21826 &_swigt__p_wxWindowDestroyEvent,
21827 &_swigt__p_wxXPMHandler,
21828 };
21829
21830 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21831 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
21832 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21833 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
21834 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
21835 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21836 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
21837 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
21838 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
21839 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
21840 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
21841 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
21842 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
21843 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
21844 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21845 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
21846 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
21847 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
21848 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
21849 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
21850 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_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_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_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}};
21851 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
21852 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}};
21853 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
21854 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
21855 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21856 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
21857 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
21858 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
21859 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
21860 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
21861 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
21862 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
21863 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
21864 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
21865 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21866 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21867 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
21868 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21869 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
21870 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
21871 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
21872 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
21873 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
21874 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
21875 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
21876 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
21877 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
21878 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
21879 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
21880 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
21881 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
21882 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
21883 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_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}};
21884 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
21885 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
21886 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
21887 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
21888 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
21889 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
21890 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
21891 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
21892 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
21893 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
21894 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
21895 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
21896 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
21897 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
21898 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
21899 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
21900 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
21901 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
21902 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
21903 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
21904 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
21905 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
21906 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
21907 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
21908 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
21909 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
21910 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
21911 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
21912 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
21913 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
21914 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
21915 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
21916 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
21917 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
21918 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
21919 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
21920 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
21921 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
21922 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
21923 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
21924 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
21925 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
21926 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
21927 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
21928 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
21929 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
21930 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
21931 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
21932 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}};
21933 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
21934 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
21935 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
21936 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
21937 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}};
21938 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
21939 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
21940 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}};
21941 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
21942 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
21943 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
21944 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
21945 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
21946 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
21947 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}};
21948 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}};
21949 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}};
21950 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}};
21951 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
21952 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
21953 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
21954 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
21955 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
21956 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}};
21957 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
21958 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
21959 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}};
21960 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
21961 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
21962 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
21963 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
21964 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
21965 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
21966 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
21967 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
21968 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
21969 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
21970 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
21971 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
21972 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
21973 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
21974 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
21975 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
21976 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
21977 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
21978 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
21979 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
21980 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
21981 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
21982 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
21983 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
21984 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
21985 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
21986 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
21987 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
21988 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
21989 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
21990 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
21991 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
21992 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
21993 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
21994 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
21995 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
21996 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
21997 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
21998 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
21999 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22000 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22001 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22002 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22003 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22004 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22005 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22006 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22007 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22008 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22009 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22010 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22011 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22012 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}};
22013 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22014 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22015 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_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_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_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22016
22017 static swig_cast_info *swig_cast_initial[] = {
22018 _swigc__p_char,
22019 _swigc__p_form_ops_t,
22020 _swigc__p_int,
22021 _swigc__p_long,
22022 _swigc__p_unsigned_char,
22023 _swigc__p_unsigned_int,
22024 _swigc__p_unsigned_long,
22025 _swigc__p_wxANIHandler,
22026 _swigc__p_wxAcceleratorTable,
22027 _swigc__p_wxActivateEvent,
22028 _swigc__p_wxArrayString,
22029 _swigc__p_wxBMPHandler,
22030 _swigc__p_wxBoxSizer,
22031 _swigc__p_wxCURHandler,
22032 _swigc__p_wxCalculateLayoutEvent,
22033 _swigc__p_wxChildFocusEvent,
22034 _swigc__p_wxCloseEvent,
22035 _swigc__p_wxColour,
22036 _swigc__p_wxColourData,
22037 _swigc__p_wxColourDialog,
22038 _swigc__p_wxCommandEvent,
22039 _swigc__p_wxContextMenuEvent,
22040 _swigc__p_wxControl,
22041 _swigc__p_wxControlWithItems,
22042 _swigc__p_wxDC,
22043 _swigc__p_wxDateEvent,
22044 _swigc__p_wxDialog,
22045 _swigc__p_wxDirDialog,
22046 _swigc__p_wxDisplayChangedEvent,
22047 _swigc__p_wxDropFilesEvent,
22048 _swigc__p_wxDuplexMode,
22049 _swigc__p_wxEraseEvent,
22050 _swigc__p_wxEvent,
22051 _swigc__p_wxEvtHandler,
22052 _swigc__p_wxFSFile,
22053 _swigc__p_wxFileDialog,
22054 _swigc__p_wxFileSystem,
22055 _swigc__p_wxFindDialogEvent,
22056 _swigc__p_wxFindReplaceData,
22057 _swigc__p_wxFindReplaceDialog,
22058 _swigc__p_wxFlexGridSizer,
22059 _swigc__p_wxFocusEvent,
22060 _swigc__p_wxFont,
22061 _swigc__p_wxFontData,
22062 _swigc__p_wxFontDialog,
22063 _swigc__p_wxFrame,
22064 _swigc__p_wxGBSizerItem,
22065 _swigc__p_wxGIFHandler,
22066 _swigc__p_wxGrid,
22067 _swigc__p_wxGridBagSizer,
22068 _swigc__p_wxGridCellAttr,
22069 _swigc__p_wxGridCellAttrProvider,
22070 _swigc__p_wxGridCellAutoWrapStringEditor,
22071 _swigc__p_wxGridCellAutoWrapStringRenderer,
22072 _swigc__p_wxGridCellBoolEditor,
22073 _swigc__p_wxGridCellBoolRenderer,
22074 _swigc__p_wxGridCellChoiceEditor,
22075 _swigc__p_wxGridCellCoords,
22076 _swigc__p_wxGridCellDateTimeRenderer,
22077 _swigc__p_wxGridCellEditor,
22078 _swigc__p_wxGridCellEnumEditor,
22079 _swigc__p_wxGridCellEnumRenderer,
22080 _swigc__p_wxGridCellFloatEditor,
22081 _swigc__p_wxGridCellFloatRenderer,
22082 _swigc__p_wxGridCellNumberEditor,
22083 _swigc__p_wxGridCellNumberRenderer,
22084 _swigc__p_wxGridCellRenderer,
22085 _swigc__p_wxGridCellStringRenderer,
22086 _swigc__p_wxGridCellTextEditor,
22087 _swigc__p_wxGridCellWorker,
22088 _swigc__p_wxGridEditorCreatedEvent,
22089 _swigc__p_wxGridEvent,
22090 _swigc__p_wxGridRangeSelectEvent,
22091 _swigc__p_wxGridSizeEvent,
22092 _swigc__p_wxGridSizer,
22093 _swigc__p_wxGridStringTable,
22094 _swigc__p_wxGridTableBase,
22095 _swigc__p_wxGridTableMessage,
22096 _swigc__p_wxICOHandler,
22097 _swigc__p_wxIconizeEvent,
22098 _swigc__p_wxIdleEvent,
22099 _swigc__p_wxImage,
22100 _swigc__p_wxImageHandler,
22101 _swigc__p_wxIndividualLayoutConstraint,
22102 _swigc__p_wxInitDialogEvent,
22103 _swigc__p_wxJPEGHandler,
22104 _swigc__p_wxKeyEvent,
22105 _swigc__p_wxLayoutAlgorithm,
22106 _swigc__p_wxLayoutConstraints,
22107 _swigc__p_wxMDIChildFrame,
22108 _swigc__p_wxMDIClientWindow,
22109 _swigc__p_wxMDIParentFrame,
22110 _swigc__p_wxMaximizeEvent,
22111 _swigc__p_wxMenu,
22112 _swigc__p_wxMenuBar,
22113 _swigc__p_wxMenuEvent,
22114 _swigc__p_wxMenuItem,
22115 _swigc__p_wxMessageDialog,
22116 _swigc__p_wxMiniFrame,
22117 _swigc__p_wxMouseCaptureChangedEvent,
22118 _swigc__p_wxMouseEvent,
22119 _swigc__p_wxMoveEvent,
22120 _swigc__p_wxMultiChoiceDialog,
22121 _swigc__p_wxNavigationKeyEvent,
22122 _swigc__p_wxNcPaintEvent,
22123 _swigc__p_wxNotifyEvent,
22124 _swigc__p_wxObject,
22125 _swigc__p_wxPCXHandler,
22126 _swigc__p_wxPNGHandler,
22127 _swigc__p_wxPNMHandler,
22128 _swigc__p_wxPageSetupDialog,
22129 _swigc__p_wxPageSetupDialogData,
22130 _swigc__p_wxPaintEvent,
22131 _swigc__p_wxPaletteChangedEvent,
22132 _swigc__p_wxPanel,
22133 _swigc__p_wxPaperSize,
22134 _swigc__p_wxPasswordEntryDialog,
22135 _swigc__p_wxPoint,
22136 _swigc__p_wxPopupWindow,
22137 _swigc__p_wxPreviewCanvas,
22138 _swigc__p_wxPreviewControlBar,
22139 _swigc__p_wxPreviewFrame,
22140 _swigc__p_wxPrintData,
22141 _swigc__p_wxPrintDialog,
22142 _swigc__p_wxPrintDialogData,
22143 _swigc__p_wxPrintPreview,
22144 _swigc__p_wxPrinter,
22145 _swigc__p_wxProgressDialog,
22146 _swigc__p_wxPyApp,
22147 _swigc__p_wxPyCommandEvent,
22148 _swigc__p_wxPyEvent,
22149 _swigc__p_wxPyGridCellAttrProvider,
22150 _swigc__p_wxPyGridCellEditor,
22151 _swigc__p_wxPyGridCellRenderer,
22152 _swigc__p_wxPyGridTableBase,
22153 _swigc__p_wxPyHtmlListBox,
22154 _swigc__p_wxPyImageHandler,
22155 _swigc__p_wxPyPanel,
22156 _swigc__p_wxPyPopupTransientWindow,
22157 _swigc__p_wxPyPreviewControlBar,
22158 _swigc__p_wxPyPreviewFrame,
22159 _swigc__p_wxPyPrintPreview,
22160 _swigc__p_wxPyPrintout,
22161 _swigc__p_wxPyScrolledWindow,
22162 _swigc__p_wxPySizer,
22163 _swigc__p_wxPyTaskBarIcon,
22164 _swigc__p_wxPyVListBox,
22165 _swigc__p_wxPyVScrolledWindow,
22166 _swigc__p_wxPyValidator,
22167 _swigc__p_wxPyWindow,
22168 _swigc__p_wxQueryLayoutInfoEvent,
22169 _swigc__p_wxQueryNewPaletteEvent,
22170 _swigc__p_wxRect,
22171 _swigc__p_wxSashEvent,
22172 _swigc__p_wxSashLayoutWindow,
22173 _swigc__p_wxSashWindow,
22174 _swigc__p_wxScrollEvent,
22175 _swigc__p_wxScrollWinEvent,
22176 _swigc__p_wxScrolledWindow,
22177 _swigc__p_wxSetCursorEvent,
22178 _swigc__p_wxShowEvent,
22179 _swigc__p_wxSingleChoiceDialog,
22180 _swigc__p_wxSizeEvent,
22181 _swigc__p_wxSizer,
22182 _swigc__p_wxSizerItem,
22183 _swigc__p_wxSplashScreen,
22184 _swigc__p_wxSplashScreenWindow,
22185 _swigc__p_wxSplitterEvent,
22186 _swigc__p_wxSplitterWindow,
22187 _swigc__p_wxStaticBoxSizer,
22188 _swigc__p_wxStatusBar,
22189 _swigc__p_wxStdDialogButtonSizer,
22190 _swigc__p_wxString,
22191 _swigc__p_wxSysColourChangedEvent,
22192 _swigc__p_wxTIFFHandler,
22193 _swigc__p_wxTaskBarIconEvent,
22194 _swigc__p_wxTextEntryDialog,
22195 _swigc__p_wxTipWindow,
22196 _swigc__p_wxTopLevelWindow,
22197 _swigc__p_wxUpdateUIEvent,
22198 _swigc__p_wxValidator,
22199 _swigc__p_wxVisualAttributes,
22200 _swigc__p_wxWindow,
22201 _swigc__p_wxWindowCreateEvent,
22202 _swigc__p_wxWindowDestroyEvent,
22203 _swigc__p_wxXPMHandler,
22204 };
22205
22206
22207 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22208
22209 static swig_const_info swig_const_table[] = {
22210 {0, 0, 0, 0.0, 0, 0}};
22211
22212 #ifdef __cplusplus
22213 }
22214 #endif
22215 /* -----------------------------------------------------------------------------
22216 * Type initialization:
22217 * This problem is tough by the requirement that no dynamic
22218 * memory is used. Also, since swig_type_info structures store pointers to
22219 * swig_cast_info structures and swig_cast_info structures store pointers back
22220 * to swig_type_info structures, we need some lookup code at initialization.
22221 * The idea is that swig generates all the structures that are needed.
22222 * The runtime then collects these partially filled structures.
22223 * The SWIG_InitializeModule function takes these initial arrays out of
22224 * swig_module, and does all the lookup, filling in the swig_module.types
22225 * array with the correct data and linking the correct swig_cast_info
22226 * structures together.
22227 *
22228 * The generated swig_type_info structures are assigned staticly to an initial
22229 * array. We just loop though that array, and handle each type individually.
22230 * First we lookup if this type has been already loaded, and if so, use the
22231 * loaded structure instead of the generated one. Then we have to fill in the
22232 * cast linked list. The cast data is initially stored in something like a
22233 * two-dimensional array. Each row corresponds to a type (there are the same
22234 * number of rows as there are in the swig_type_initial array). Each entry in
22235 * a column is one of the swig_cast_info structures for that type.
22236 * The cast_initial array is actually an array of arrays, because each row has
22237 * a variable number of columns. So to actually build the cast linked list,
22238 * we find the array of casts associated with the type, and loop through it
22239 * adding the casts to the list. The one last trick we need to do is making
22240 * sure the type pointer in the swig_cast_info struct is correct.
22241 *
22242 * First off, we lookup the cast->type name to see if it is already loaded.
22243 * There are three cases to handle:
22244 * 1) If the cast->type has already been loaded AND the type we are adding
22245 * casting info to has not been loaded (it is in this module), THEN we
22246 * replace the cast->type pointer with the type pointer that has already
22247 * been loaded.
22248 * 2) If BOTH types (the one we are adding casting info to, and the
22249 * cast->type) are loaded, THEN the cast info has already been loaded by
22250 * the previous module so we just ignore it.
22251 * 3) Finally, if cast->type has not already been loaded, then we add that
22252 * swig_cast_info to the linked list (because the cast->type) pointer will
22253 * be correct.
22254 * ----------------------------------------------------------------------------- */
22255
22256 #ifdef __cplusplus
22257 extern "C" {
22258 #if 0
22259 } /* c-mode */
22260 #endif
22261 #endif
22262
22263 #if 0
22264 #define SWIGRUNTIME_DEBUG
22265 #endif
22266
22267 SWIGRUNTIME void
22268 SWIG_InitializeModule(void *clientdata) {
22269 size_t i;
22270 swig_module_info *module_head;
22271 static int init_run = 0;
22272
22273 clientdata = clientdata;
22274
22275 if (init_run) return;
22276 init_run = 1;
22277
22278 /* Initialize the swig_module */
22279 swig_module.type_initial = swig_type_initial;
22280 swig_module.cast_initial = swig_cast_initial;
22281
22282 /* Try and load any already created modules */
22283 module_head = SWIG_GetModule(clientdata);
22284 if (module_head) {
22285 swig_module.next = module_head->next;
22286 module_head->next = &swig_module;
22287 } else {
22288 /* This is the first module loaded */
22289 swig_module.next = &swig_module;
22290 SWIG_SetModule(clientdata, &swig_module);
22291 }
22292
22293 /* Now work on filling in swig_module.types */
22294 #ifdef SWIGRUNTIME_DEBUG
22295 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22296 #endif
22297 for (i = 0; i < swig_module.size; ++i) {
22298 swig_type_info *type = 0;
22299 swig_type_info *ret;
22300 swig_cast_info *cast;
22301
22302 #ifdef SWIGRUNTIME_DEBUG
22303 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22304 #endif
22305
22306 /* if there is another module already loaded */
22307 if (swig_module.next != &swig_module) {
22308 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22309 }
22310 if (type) {
22311 /* Overwrite clientdata field */
22312 #ifdef SWIGRUNTIME_DEBUG
22313 printf("SWIG_InitializeModule: found type %s\n", type->name);
22314 #endif
22315 if (swig_module.type_initial[i]->clientdata) {
22316 type->clientdata = swig_module.type_initial[i]->clientdata;
22317 #ifdef SWIGRUNTIME_DEBUG
22318 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22319 #endif
22320 }
22321 } else {
22322 type = swig_module.type_initial[i];
22323 }
22324
22325 /* Insert casting types */
22326 cast = swig_module.cast_initial[i];
22327 while (cast->type) {
22328 /* Don't need to add information already in the list */
22329 ret = 0;
22330 #ifdef SWIGRUNTIME_DEBUG
22331 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22332 #endif
22333 if (swig_module.next != &swig_module) {
22334 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22335 #ifdef SWIGRUNTIME_DEBUG
22336 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22337 #endif
22338 }
22339 if (ret) {
22340 if (type == swig_module.type_initial[i]) {
22341 #ifdef SWIGRUNTIME_DEBUG
22342 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22343 #endif
22344 cast->type = ret;
22345 ret = 0;
22346 } else {
22347 /* Check for casting already in the list */
22348 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22349 #ifdef SWIGRUNTIME_DEBUG
22350 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22351 #endif
22352 if (!ocast) ret = 0;
22353 }
22354 }
22355
22356 if (!ret) {
22357 #ifdef SWIGRUNTIME_DEBUG
22358 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22359 #endif
22360 if (type->cast) {
22361 type->cast->prev = cast;
22362 cast->next = type->cast;
22363 }
22364 type->cast = cast;
22365 }
22366 cast++;
22367 }
22368 /* Set entry in modules->types array equal to the type */
22369 swig_module.types[i] = type;
22370 }
22371 swig_module.types[i] = 0;
22372
22373 #ifdef SWIGRUNTIME_DEBUG
22374 printf("**** SWIG_InitializeModule: Cast List ******\n");
22375 for (i = 0; i < swig_module.size; ++i) {
22376 int j = 0;
22377 swig_cast_info *cast = swig_module.cast_initial[i];
22378 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22379 while (cast->type) {
22380 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22381 cast++;
22382 ++j;
22383 }
22384 printf("---- Total casts: %d\n",j);
22385 }
22386 printf("**** SWIG_InitializeModule: Cast List ******\n");
22387 #endif
22388 }
22389
22390 /* This function will propagate the clientdata field of type to
22391 * any new swig_type_info structures that have been added into the list
22392 * of equivalent types. It is like calling
22393 * SWIG_TypeClientData(type, clientdata) a second time.
22394 */
22395 SWIGRUNTIME void
22396 SWIG_PropagateClientData(void) {
22397 size_t i;
22398 swig_cast_info *equiv;
22399 static int init_run = 0;
22400
22401 if (init_run) return;
22402 init_run = 1;
22403
22404 for (i = 0; i < swig_module.size; i++) {
22405 if (swig_module.types[i]->clientdata) {
22406 equiv = swig_module.types[i]->cast;
22407 while (equiv) {
22408 if (!equiv->converter) {
22409 if (equiv->type && !equiv->type->clientdata)
22410 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22411 }
22412 equiv = equiv->next;
22413 }
22414 }
22415 }
22416 }
22417
22418 #ifdef __cplusplus
22419 #if 0
22420 {
22421 /* c-mode */
22422 #endif
22423 }
22424 #endif
22425
22426
22427
22428 #ifdef __cplusplus
22429 extern "C" {
22430 #endif
22431
22432 /* Python-specific SWIG API */
22433 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22434 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22435 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22436
22437 /* -----------------------------------------------------------------------------
22438 * global variable support code.
22439 * ----------------------------------------------------------------------------- */
22440
22441 typedef struct swig_globalvar {
22442 char *name; /* Name of global variable */
22443 PyObject *(*get_attr)(void); /* Return the current value */
22444 int (*set_attr)(PyObject *); /* Set the value */
22445 struct swig_globalvar *next;
22446 } swig_globalvar;
22447
22448 typedef struct swig_varlinkobject {
22449 PyObject_HEAD
22450 swig_globalvar *vars;
22451 } swig_varlinkobject;
22452
22453 SWIGINTERN PyObject *
22454 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22455 return PyString_FromString("<Swig global variables>");
22456 }
22457
22458 SWIGINTERN PyObject *
22459 swig_varlink_str(swig_varlinkobject *v) {
22460 PyObject *str = PyString_FromString("(");
22461 swig_globalvar *var;
22462 for (var = v->vars; var; var=var->next) {
22463 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22464 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22465 }
22466 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22467 return str;
22468 }
22469
22470 SWIGINTERN int
22471 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22472 PyObject *str = swig_varlink_str(v);
22473 fprintf(fp,"Swig global variables ");
22474 fprintf(fp,"%s\n", PyString_AsString(str));
22475 Py_DECREF(str);
22476 return 0;
22477 }
22478
22479 SWIGINTERN void
22480 swig_varlink_dealloc(swig_varlinkobject *v) {
22481 swig_globalvar *var = v->vars;
22482 while (var) {
22483 swig_globalvar *n = var->next;
22484 free(var->name);
22485 free(var);
22486 var = n;
22487 }
22488 }
22489
22490 SWIGINTERN PyObject *
22491 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22492 PyObject *res = NULL;
22493 swig_globalvar *var = v->vars;
22494 while (var) {
22495 if (strcmp(var->name,n) == 0) {
22496 res = (*var->get_attr)();
22497 break;
22498 }
22499 var = var->next;
22500 }
22501 if (res == NULL && !PyErr_Occurred()) {
22502 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22503 }
22504 return res;
22505 }
22506
22507 SWIGINTERN int
22508 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22509 int res = 1;
22510 swig_globalvar *var = v->vars;
22511 while (var) {
22512 if (strcmp(var->name,n) == 0) {
22513 res = (*var->set_attr)(p);
22514 break;
22515 }
22516 var = var->next;
22517 }
22518 if (res == 1 && !PyErr_Occurred()) {
22519 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22520 }
22521 return res;
22522 }
22523
22524 SWIGINTERN PyTypeObject*
22525 swig_varlink_type(void) {
22526 static char varlink__doc__[] = "Swig var link object";
22527 static PyTypeObject varlink_type;
22528 static int type_init = 0;
22529 if (!type_init) {
22530 const PyTypeObject tmp
22531 = {
22532 PyObject_HEAD_INIT(NULL)
22533 0, /* Number of items in variable part (ob_size) */
22534 (char *)"swigvarlink", /* Type name (tp_name) */
22535 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22536 0, /* Itemsize (tp_itemsize) */
22537 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22538 (printfunc) swig_varlink_print, /* Print (tp_print) */
22539 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22540 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22541 0, /* tp_compare */
22542 (reprfunc) swig_varlink_repr, /* tp_repr */
22543 0, /* tp_as_number */
22544 0, /* tp_as_sequence */
22545 0, /* tp_as_mapping */
22546 0, /* tp_hash */
22547 0, /* tp_call */
22548 (reprfunc)swig_varlink_str, /* tp_str */
22549 0, /* tp_getattro */
22550 0, /* tp_setattro */
22551 0, /* tp_as_buffer */
22552 0, /* tp_flags */
22553 varlink__doc__, /* tp_doc */
22554 0, /* tp_traverse */
22555 0, /* tp_clear */
22556 0, /* tp_richcompare */
22557 0, /* tp_weaklistoffset */
22558 #if PY_VERSION_HEX >= 0x02020000
22559 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22560 #endif
22561 #if PY_VERSION_HEX >= 0x02030000
22562 0, /* tp_del */
22563 #endif
22564 #ifdef COUNT_ALLOCS
22565 0,0,0,0 /* tp_alloc -> tp_next */
22566 #endif
22567 };
22568 varlink_type = tmp;
22569 varlink_type.ob_type = &PyType_Type;
22570 type_init = 1;
22571 }
22572 return &varlink_type;
22573 }
22574
22575 /* Create a variable linking object for use later */
22576 SWIGINTERN PyObject *
22577 SWIG_Python_newvarlink(void) {
22578 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22579 if (result) {
22580 result->vars = 0;
22581 }
22582 return ((PyObject*) result);
22583 }
22584
22585 SWIGINTERN void
22586 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22587 swig_varlinkobject *v = (swig_varlinkobject *) p;
22588 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22589 if (gv) {
22590 size_t size = strlen(name)+1;
22591 gv->name = (char *)malloc(size);
22592 if (gv->name) {
22593 strncpy(gv->name,name,size);
22594 gv->get_attr = get_attr;
22595 gv->set_attr = set_attr;
22596 gv->next = v->vars;
22597 }
22598 }
22599 v->vars = gv;
22600 }
22601
22602 SWIGINTERN PyObject *
22603 SWIG_globals() {
22604 static PyObject *_SWIG_globals = 0;
22605 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22606 return _SWIG_globals;
22607 }
22608
22609 /* -----------------------------------------------------------------------------
22610 * constants/methods manipulation
22611 * ----------------------------------------------------------------------------- */
22612
22613 /* Install Constants */
22614 SWIGINTERN void
22615 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22616 PyObject *obj = 0;
22617 size_t i;
22618 for (i = 0; constants[i].type; ++i) {
22619 switch(constants[i].type) {
22620 case SWIG_PY_POINTER:
22621 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22622 break;
22623 case SWIG_PY_BINARY:
22624 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22625 break;
22626 default:
22627 obj = 0;
22628 break;
22629 }
22630 if (obj) {
22631 PyDict_SetItemString(d, constants[i].name, obj);
22632 Py_DECREF(obj);
22633 }
22634 }
22635 }
22636
22637 /* -----------------------------------------------------------------------------*/
22638 /* Fix SwigMethods to carry the callback ptrs when needed */
22639 /* -----------------------------------------------------------------------------*/
22640
22641 SWIGINTERN void
22642 SWIG_Python_FixMethods(PyMethodDef *methods,
22643 swig_const_info *const_table,
22644 swig_type_info **types,
22645 swig_type_info **types_initial) {
22646 size_t i;
22647 for (i = 0; methods[i].ml_name; ++i) {
22648 char *c = methods[i].ml_doc;
22649 if (c && (c = strstr(c, "swig_ptr: "))) {
22650 int j;
22651 swig_const_info *ci = 0;
22652 char *name = c + 10;
22653 for (j = 0; const_table[j].type; ++j) {
22654 if (strncmp(const_table[j].name, name,
22655 strlen(const_table[j].name)) == 0) {
22656 ci = &(const_table[j]);
22657 break;
22658 }
22659 }
22660 if (ci) {
22661 size_t shift = (ci->ptype) - types;
22662 swig_type_info *ty = types_initial[shift];
22663 size_t ldoc = (c - methods[i].ml_doc);
22664 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22665 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22666 if (ndoc) {
22667 char *buff = ndoc;
22668 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22669 if (ptr) {
22670 strncpy(buff, methods[i].ml_doc, ldoc);
22671 buff += ldoc;
22672 strncpy(buff, "swig_ptr: ", 10);
22673 buff += 10;
22674 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22675 methods[i].ml_doc = ndoc;
22676 }
22677 }
22678 }
22679 }
22680 }
22681 }
22682
22683 #ifdef __cplusplus
22684 }
22685 #endif
22686
22687 /* -----------------------------------------------------------------------------*
22688 * Partial Init method
22689 * -----------------------------------------------------------------------------*/
22690
22691 #ifdef __cplusplus
22692 extern "C"
22693 #endif
22694 SWIGEXPORT void SWIG_init(void) {
22695 PyObject *m, *d;
22696
22697 /* Fix SwigMethods to carry the callback ptrs when needed */
22698 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
22699
22700 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22701 d = PyModule_GetDict(m);
22702
22703 SWIG_InitializeModule(0);
22704 SWIG_InstallConstants(d,swig_const_table);
22705
22706
22707 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
22708 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
22709 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
22710 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
22711 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
22712 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
22713 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
22714 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
22715 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
22716 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
22717 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
22718 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
22719 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
22720 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
22721 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
22722 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
22723 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
22724 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
22725 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
22726 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
22727 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
22728 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
22729 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
22730 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
22731 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
22732 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
22733 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
22734 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
22735 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
22736 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
22737 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
22738 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
22739 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
22740 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
22741 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
22742 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
22743 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
22744 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
22745 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
22746 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
22747 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
22748 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
22749 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
22750 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
22751 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
22752 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
22753 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
22754 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
22755 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
22756 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
22757 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
22758 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
22759 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
22760 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
22761 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
22762 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
22763
22764
22765 }
22766
wxWidgets (Impactor)