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


577bf1f4efecb572ec3aa781b48b9f75eeae8a1a
[wxWidgets.git] / wxPython / src / msw / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMoveEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[104]
2571 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNcPaintEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNotifyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxPCXHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNGHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNMHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialog swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPanel swig_types[117]
2584 #define SWIGTYPE_p_wxPaperSize swig_types[118]
2585 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[119]
2586 #define SWIGTYPE_p_wxPen swig_types[120]
2587 #define SWIGTYPE_p_wxPoint swig_types[121]
2588 #define SWIGTYPE_p_wxPopupWindow swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewCanvas swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewControlBar swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewFrame swig_types[125]
2592 #define SWIGTYPE_p_wxPrintData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialog swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialogData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintPreview swig_types[129]
2596 #define SWIGTYPE_p_wxPrinter swig_types[130]
2597 #define SWIGTYPE_p_wxProgressDialog swig_types[131]
2598 #define SWIGTYPE_p_wxPyApp swig_types[132]
2599 #define SWIGTYPE_p_wxPyCommandEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridTableBase swig_types[138]
2605 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[139]
2606 #define SWIGTYPE_p_wxPyImageHandler swig_types[140]
2607 #define SWIGTYPE_p_wxPyPanel swig_types[141]
2608 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintPreview swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintout swig_types[146]
2613 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[147]
2614 #define SWIGTYPE_p_wxPySizer swig_types[148]
2615 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[149]
2616 #define SWIGTYPE_p_wxPyVListBox swig_types[150]
2617 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPyValidator swig_types[152]
2619 #define SWIGTYPE_p_wxPyWindow swig_types[153]
2620 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[154]
2621 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[155]
2622 #define SWIGTYPE_p_wxRect swig_types[156]
2623 #define SWIGTYPE_p_wxSashEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[158]
2625 #define SWIGTYPE_p_wxSashWindow swig_types[159]
2626 #define SWIGTYPE_p_wxScrollEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrollWinEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrolledWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSetCursorEvent swig_types[163]
2630 #define SWIGTYPE_p_wxShowEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[165]
2632 #define SWIGTYPE_p_wxSize swig_types[166]
2633 #define SWIGTYPE_p_wxSizeEvent swig_types[167]
2634 #define SWIGTYPE_p_wxSizer swig_types[168]
2635 #define SWIGTYPE_p_wxSizerItem swig_types[169]
2636 #define SWIGTYPE_p_wxSplashScreen swig_types[170]
2637 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[171]
2638 #define SWIGTYPE_p_wxSplitterEvent swig_types[172]
2639 #define SWIGTYPE_p_wxSplitterWindow swig_types[173]
2640 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[174]
2641 #define SWIGTYPE_p_wxStatusBar swig_types[175]
2642 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[176]
2643 #define SWIGTYPE_p_wxString swig_types[177]
2644 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[178]
2645 #define SWIGTYPE_p_wxTIFFHandler swig_types[179]
2646 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[180]
2647 #define SWIGTYPE_p_wxTextEntryDialog swig_types[181]
2648 #define SWIGTYPE_p_wxTipWindow swig_types[182]
2649 #define SWIGTYPE_p_wxTopLevelWindow swig_types[183]
2650 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[184]
2651 #define SWIGTYPE_p_wxValidator swig_types[185]
2652 #define SWIGTYPE_p_wxVisualAttributes swig_types[186]
2653 #define SWIGTYPE_p_wxWindow swig_types[187]
2654 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[188]
2655 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[189]
2656 #define SWIGTYPE_p_wxXPMHandler swig_types[190]
2657 static swig_type_info *swig_types[192];
2658 static swig_module_info swig_module = {swig_types, 191, 0, 0, 0, 0};
2659 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2660 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2661
2662 /* -------- TYPES TABLE (END) -------- */
2663
2664 #if (PY_VERSION_HEX <= 0x02000000)
2665 # if !defined(SWIG_PYTHON_CLASSIC)
2666 # error "This python version requires to use swig with the '-classic' option"
2667 # endif
2668 #endif
2669 #if (PY_VERSION_HEX <= 0x02020000)
2670 # error "This python version requires to use swig with the '-nomodern' option"
2671 #endif
2672 #if (PY_VERSION_HEX <= 0x02020000)
2673 # error "This python version requires to use swig with the '-nomodernargs' option"
2674 #endif
2675 #ifndef METH_O
2676 # error "This python version requires to use swig with the '-nofastunpack' option"
2677 #endif
2678
2679 /*-----------------------------------------------
2680 @(target):= _grid.so
2681 ------------------------------------------------*/
2682 #define SWIG_init init_grid
2683
2684 #define SWIG_name "_grid"
2685
2686 #define SWIGVERSION 0x010329
2687
2688
2689 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2690 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2691
2692
2693 #include <stdexcept>
2694
2695
2696 namespace swig {
2697 class PyObject_ptr {
2698 protected:
2699 PyObject *_obj;
2700
2701 public:
2702 PyObject_ptr() :_obj(0)
2703 {
2704 }
2705
2706 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2707 {
2708 Py_XINCREF(_obj);
2709 }
2710
2711 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2712 {
2713 if (initial_ref) Py_XINCREF(_obj);
2714 }
2715
2716 PyObject_ptr & operator=(const PyObject_ptr& item)
2717 {
2718 Py_XINCREF(item._obj);
2719 Py_XDECREF(_obj);
2720 _obj = item._obj;
2721 return *this;
2722 }
2723
2724 ~PyObject_ptr()
2725 {
2726 Py_XDECREF(_obj);
2727 }
2728
2729 operator PyObject *() const
2730 {
2731 return _obj;
2732 }
2733
2734 PyObject *operator->() const
2735 {
2736 return _obj;
2737 }
2738 };
2739 }
2740
2741
2742 namespace swig {
2743 struct PyObject_var : PyObject_ptr {
2744 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2745
2746 PyObject_var & operator = (PyObject* obj)
2747 {
2748 Py_XDECREF(_obj);
2749 _obj = obj;
2750 return *this;
2751 }
2752 };
2753 }
2754
2755
2756 #include "wx/wxPython/wxPython.h"
2757 #include "wx/wxPython/pyclasses.h"
2758 #include "wx/wxPython/printfw.h"
2759
2760 #include <wx/grid.h>
2761 #include <wx/generic/gridctrl.h>
2762
2763
2764 static const wxString wxPyEmptyString(wxEmptyString);
2765 static const wxString wxPyGridNameStr(wxGridNameStr);
2766 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2767
2768
2769 #define wxPyMake_TEMPLATE(TYPE) \
2770 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2771 PyObject* target = NULL; \
2772 if (source) { \
2773 /* Check if there is already a pointer to a Python object in the \
2774 OOR data that we can use. */ \
2775 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2776 if (data) { \
2777 target = data->m_obj; \
2778 if (target) \
2779 Py_INCREF(target); \
2780 } \
2781 /* Otherwise make a new wrapper for it the old fashioned way and \
2782 give it the OOR treatment */ \
2783 if (! target) { \
2784 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2785 if (target) \
2786 source->SetClientObject(new wxPyOORClientData(target)); \
2787 } \
2788 } else { /* source was NULL so return None. */ \
2789 Py_INCREF(Py_None); target = Py_None; \
2790 } \
2791 return target; \
2792 } \
2793
2794
2795 wxPyMake_TEMPLATE(wxGridCellRenderer)
2796 wxPyMake_TEMPLATE(wxGridCellEditor)
2797 wxPyMake_TEMPLATE(wxGridCellAttr)
2798 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2799 wxPyMake_TEMPLATE(wxGridTableBase)
2800
2801
2802
2803 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2804 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2805 wxGridCellAttr* rval = NULL; \
2806 bool found; \
2807 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2808 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2809 PyObject* ro; \
2810 wxGridCellAttr* ptr; \
2811 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2812 if (ro) { \
2813 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2814 rval = ptr; \
2815 Py_DECREF(ro); \
2816 } \
2817 } \
2818 wxPyEndBlockThreads(blocked); \
2819 if (! found) \
2820 rval = PCLASS::CBNAME(a, b, c); \
2821 return rval; \
2822 }
2823
2824
2825 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2826 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2828 bool found; \
2829 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2830 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2831 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2832 Py_DECREF(obj); \
2833 } \
2834 wxPyEndBlockThreads(blocked); \
2835 if (! found) \
2836 PCLASS::CBNAME(attr, a, b); \
2837 }
2838
2839
2840
2841 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2842 void CBNAME(wxGridCellAttr *attr, int val) { \
2843 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2844 bool found; \
2845 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2846 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2847 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2848 Py_DECREF(obj); \
2849 } \
2850 wxPyEndBlockThreads(blocked); \
2851 if (! found) \
2852 PCLASS::CBNAME(attr, val); \
2853 }
2854
2855
2856
2857 #define PYCALLBACK_INT__pure(CBNAME) \
2858 int CBNAME() { \
2859 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2860 int rval = 0; \
2861 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2862 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2863 wxPyEndBlockThreads(blocked); \
2864 return rval; \
2865 }
2866
2867
2868
2869 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2870 bool CBNAME(int a, int b) { \
2871 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2872 bool rval = 0; \
2873 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2874 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2875 wxPyEndBlockThreads(blocked); \
2876 return rval; \
2877 }
2878
2879
2880 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2881 wxString CBNAME(int a, int b) { \
2882 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2883 wxString rval; \
2884 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2885 PyObject* ro; \
2886 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2887 if (ro) { \
2888 rval = Py2wxString(ro); \
2889 Py_DECREF(ro); \
2890 } \
2891 } \
2892 wxPyEndBlockThreads(blocked); \
2893 return rval; \
2894 }
2895
2896
2897 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2898 void CBNAME(int a, int b, const wxString& c) { \
2899 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2900 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2901 PyObject* s = wx2PyString(c); \
2902 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2903 Py_DECREF(s); \
2904 } \
2905 wxPyEndBlockThreads(blocked); \
2906 }
2907
2908
2909 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2910 wxString CBNAME(int a, int b) { \
2911 bool found; \
2912 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2913 wxString rval; \
2914 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2915 PyObject* ro; \
2916 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2917 if (ro) { \
2918 rval = Py2wxString(ro); \
2919 Py_DECREF(ro); \
2920 } \
2921 } \
2922 wxPyEndBlockThreads(blocked); \
2923 if (! found) \
2924 rval = PCLASS::CBNAME(a, b); \
2925 return rval; \
2926 }
2927
2928
2929 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2930 bool CBNAME(int a, int b, const wxString& c) { \
2931 bool rval = 0; \
2932 bool found; \
2933 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2934 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2935 PyObject* s = wx2PyString(c); \
2936 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2937 Py_DECREF(s); \
2938 } \
2939 wxPyEndBlockThreads(blocked); \
2940 if (! found) \
2941 rval = PCLASS::CBNAME(a,b,c); \
2942 return rval; \
2943 }
2944
2945
2946
2947
2948 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2949 long CBNAME(int a, int b) { \
2950 long rval; \
2951 bool found; \
2952 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2953 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2954 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2955 wxPyEndBlockThreads(blocked); \
2956 if (! found) \
2957 rval = PCLASS::CBNAME(a,b); \
2958 return rval; \
2959 }
2960
2961
2962 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2963 bool CBNAME(int a, int b) { \
2964 bool rval = 0; \
2965 bool found; \
2966 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2967 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2968 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2969 wxPyEndBlockThreads(blocked); \
2970 if (! found) \
2971 rval = PCLASS::CBNAME(a,b); \
2972 return rval; \
2973 }
2974
2975
2976
2977 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2978 double CBNAME(int a, int b) { \
2979 bool found; \
2980 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2981 double rval; \
2982 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2983 PyObject* ro; \
2984 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2985 if (ro) { \
2986 PyObject* str = PyObject_Str(ro); \
2987 rval = PyFloat_AsDouble(str); \
2988 Py_DECREF(ro); Py_DECREF(str); \
2989 } \
2990 } \
2991 wxPyEndBlockThreads(blocked); \
2992 if (! found) \
2993 rval = PCLASS::CBNAME(a, b); \
2994 return rval; \
2995 }
2996
2997
2998
2999 #define PYCALLBACK__(PCLASS, CBNAME) \
3000 void CBNAME() { \
3001 bool found; \
3002 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3003 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3004 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3005 wxPyEndBlockThreads(blocked); \
3006 if (! found) \
3007 PCLASS::CBNAME(); \
3008 }
3009
3010
3011
3012 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3013 bool CBNAME(size_t a, size_t b) { \
3014 bool rval = 0; \
3015 bool found; \
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3017 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3018 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3019 wxPyEndBlockThreads(blocked); \
3020 if (! found) \
3021 rval = PCLASS::CBNAME(a,b); \
3022 return rval; \
3023 }
3024
3025
3026
3027 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3028 bool CBNAME(size_t a) { \
3029 bool rval = 0; \
3030 bool found; \
3031 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3032 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3033 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3034 wxPyEndBlockThreads(blocked); \
3035 if (! found) \
3036 rval = PCLASS::CBNAME(a); \
3037 return rval; \
3038 }
3039
3040
3041 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3042 wxString CBNAME(int a) { \
3043 bool found; \
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3045 wxString rval; \
3046 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3047 PyObject* ro; \
3048 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3049 if (ro) { \
3050 rval = Py2wxString(ro); \
3051 Py_DECREF(ro); \
3052 } \
3053 } \
3054 wxPyEndBlockThreads(blocked); \
3055 if (! found) \
3056 rval = PCLASS::CBNAME(a); \
3057 return rval; \
3058 }
3059
3060
3061 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3062 void CBNAME(int a, const wxString& c) { \
3063 bool found; \
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3065 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3066 PyObject* s = wx2PyString(c); \
3067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3068 Py_DECREF(s); \
3069 } \
3070 wxPyEndBlockThreads(blocked); \
3071 if (! found) \
3072 PCLASS::CBNAME(a,c); \
3073 }
3074
3075
3076
3077
3078 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3079 bool CBNAME() { \
3080 bool rval = 0; \
3081 bool found; \
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3083 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3084 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3085 wxPyEndBlockThreads(blocked); \
3086 if (! found) \
3087 rval = PCLASS::CBNAME(); \
3088 return rval; \
3089 }
3090
3091
3092
3093 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3094 void CBNAME(size_t a, int b) { \
3095 bool found; \
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3097 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3098 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3099 wxPyEndBlockThreads(blocked); \
3100 if (! found) \
3101 PCLASS::CBNAME(a,b); \
3102 }
3103
3104
3105
3106
3107 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3108 void CBNAME(int a, int b, long c) { \
3109 bool found; \
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3111 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3112 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3113 wxPyEndBlockThreads(blocked); \
3114 if (! found) \
3115 PCLASS::CBNAME(a,b,c); \
3116 }
3117
3118
3119
3120
3121 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3122 void CBNAME(int a, int b, double c) { \
3123 bool found; \
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3125 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3126 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3127 wxPyEndBlockThreads(blocked); \
3128 if (! found) \
3129 PCLASS::CBNAME(a,b,c); \
3130 }
3131
3132
3133
3134 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3135 void CBNAME(int a, int b, bool c) { \
3136 bool found; \
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3138 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3139 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3140 wxPyEndBlockThreads(blocked); \
3141 if (! found) \
3142 PCLASS::CBNAME(a,b,c); \
3143 }
3144
3145
3146
3147
3148
3149 SWIGINTERN swig_type_info*
3150 SWIG_pchar_descriptor()
3151 {
3152 static int init = 0;
3153 static swig_type_info* info = 0;
3154 if (!init) {
3155 info = SWIG_TypeQuery("_p_char");
3156 init = 1;
3157 }
3158 return info;
3159 }
3160
3161
3162 SWIGINTERNINLINE PyObject *
3163 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3164 {
3165 if (carray) {
3166 if (size > INT_MAX) {
3167 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3168 return pchar_descriptor ?
3169 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3170 } else {
3171 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3172 }
3173 } else {
3174 return SWIG_Py_Void();
3175 }
3176 }
3177
3178
3179 SWIGINTERNINLINE PyObject *
3180 SWIG_FromCharPtr(const char *cptr)
3181 {
3182 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3183 }
3184
3185
3186 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3187 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3188 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3189 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3190 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3191 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3192 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3193 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3194 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3195 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3196
3197
3198 #define SWIG_From_long PyInt_FromLong
3199
3200
3201 SWIGINTERNINLINE PyObject *
3202 SWIG_From_int (int value)
3203 {
3204 return SWIG_From_long (value);
3205 }
3206
3207 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3208 if (!self->GetClientObject())
3209 self->SetClientObject(new wxPyOORClientData(_self));
3210 }
3211 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3212 }
3213
3214 #include <limits.h>
3215 #ifndef LLONG_MIN
3216 # define LLONG_MIN LONG_LONG_MIN
3217 #endif
3218 #ifndef LLONG_MAX
3219 # define LLONG_MAX LONG_LONG_MAX
3220 #endif
3221 #ifndef ULLONG_MAX
3222 # define ULLONG_MAX ULONG_LONG_MAX
3223 #endif
3224
3225
3226 SWIGINTERN int
3227 SWIG_AsVal_long (PyObject* obj, long* val)
3228 {
3229 if (PyNumber_Check(obj)) {
3230 if (val) *val = PyInt_AsLong(obj);
3231 return SWIG_OK;
3232 }
3233 return SWIG_TypeError;
3234 }
3235
3236
3237 SWIGINTERN int
3238 SWIG_AsVal_int (PyObject * obj, int *val)
3239 {
3240 long v;
3241 int res = SWIG_AsVal_long (obj, &v);
3242 if (SWIG_IsOK(res)) {
3243 if ((v < INT_MIN || v > INT_MAX)) {
3244 return SWIG_OverflowError;
3245 } else {
3246 if (val) *val = static_cast< int >(v);
3247 }
3248 }
3249 return res;
3250 }
3251
3252
3253 SWIGINTERN int
3254 SWIG_AsVal_bool (PyObject *obj, bool *val)
3255 {
3256 if (obj == Py_True) {
3257 if (val) *val = true;
3258 return SWIG_OK;
3259 } else if (obj == Py_False) {
3260 if (val) *val = false;
3261 return SWIG_OK;
3262 } else {
3263 long v = 0;
3264 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3265 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3266 return res;
3267 }
3268 }
3269
3270
3271 class wxPyGridCellRenderer : public wxGridCellRenderer
3272 {
3273 public:
3274 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3275
3276 // Implement Python callback aware virtual methods
3277 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3278 wxDC& dc, const wxRect& rect,
3279 int row, int col, bool isSelected) {
3280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3281 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3282 PyObject* go = wxPyMake_wxObject(&grid,false);
3283 PyObject* dco = wxPyMake_wxObject(&dc,false);
3284 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3285 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3286
3287 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3288 row, col, isSelected));
3289 Py_DECREF(go);
3290 Py_DECREF(ao);
3291 Py_DECREF(dco);
3292 Py_DECREF(ro);
3293 }
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3298 int row, int col) {
3299 wxSize rval;
3300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3301 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3302 PyObject* ro;
3303 wxSize* ptr;
3304 PyObject* go = wxPyMake_wxObject(&grid,false);
3305 PyObject* dco = wxPyMake_wxObject(&dc,false);
3306 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3307
3308 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3309 go, ao, dco,
3310 row, col));
3311 Py_DECREF(go);
3312 Py_DECREF(ao);
3313 Py_DECREF(dco);
3314
3315 if (ro) {
3316 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3317 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3318 rval = *ptr;
3319 }
3320 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3321 PyObject* o1 = PySequence_GetItem(ro, 0);
3322 PyObject* o2 = PySequence_GetItem(ro, 1);
3323 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3324 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3325 else
3326 PyErr_SetString(PyExc_TypeError, errmsg);
3327 Py_DECREF(o1);
3328 Py_DECREF(o2);
3329 }
3330 else {
3331 PyErr_SetString(PyExc_TypeError, errmsg);
3332 }
3333 Py_DECREF(ro);
3334 }
3335 }
3336 wxPyEndBlockThreads(blocked);
3337 return rval;
3338 }
3339
3340
3341 wxGridCellRenderer *Clone() const {
3342 wxGridCellRenderer* rval = NULL;
3343 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3344 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3345 PyObject* ro;
3346 wxGridCellRenderer* ptr;
3347 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3348 if (ro) {
3349 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3350 rval = ptr;
3351 Py_DECREF(ro);
3352 }
3353 }
3354 wxPyEndBlockThreads(blocked);
3355 return rval;
3356 }
3357
3358 DEC_PYCALLBACK__STRING(SetParameters);
3359
3360 PYPRIVATE;
3361 };
3362
3363 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3364
3365
3366
3367 class wxPyGridCellEditor : public wxGridCellEditor
3368 {
3369 public:
3370 wxPyGridCellEditor() : wxGridCellEditor() {}
3371
3372 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3373 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3374 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3375 PyObject* po = wxPyMake_wxObject(parent,false);
3376 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3377
3378 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3379 Py_DECREF(po);
3380 Py_DECREF(eo);
3381 }
3382 wxPyEndBlockThreads(blocked);
3383 }
3384
3385
3386 void BeginEdit(int row, int col, wxGrid* grid) {
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3389 PyObject* go = wxPyMake_wxObject(grid,false);
3390 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3391 Py_DECREF(go);
3392 }
3393 wxPyEndBlockThreads(blocked);
3394 }
3395
3396
3397 bool EndEdit(int row, int col, wxGrid* grid) {
3398 bool rv = false;
3399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3400 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3401 PyObject* go = wxPyMake_wxObject(grid,false);
3402 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3403 Py_DECREF(go);
3404 }
3405 wxPyEndBlockThreads(blocked);
3406 return rv;
3407 }
3408
3409
3410 wxGridCellEditor* Clone() const {
3411 wxGridCellEditor* rval = NULL;
3412 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3413 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3414 PyObject* ro;
3415 wxGridCellEditor* ptr;
3416 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3417 if (ro) {
3418 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3419 rval = ptr;
3420 Py_DECREF(ro);
3421 }
3422 }
3423 wxPyEndBlockThreads(blocked);
3424 return rval;
3425 }
3426
3427
3428 void Show(bool show, wxGridCellAttr *attr) {
3429 bool found;
3430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3431 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3432 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3433 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3434 Py_DECREF(ao);
3435 }
3436 wxPyEndBlockThreads(blocked);
3437 if (! found)
3438 wxGridCellEditor::Show(show, attr);
3439 }
3440
3441
3442 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3443 bool found;
3444 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3445 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3446 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3447 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3448
3449 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3450
3451 Py_DECREF(ro);
3452 Py_DECREF(ao);
3453 }
3454 wxPyEndBlockThreads(blocked);
3455 if (! found)
3456 wxGridCellEditor::PaintBackground(rectCell, attr);
3457 }
3458
3459
3460 DEC_PYCALLBACK___pure(Reset);
3461 DEC_PYCALLBACK__constany(SetSize, wxRect);
3462 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3463 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3464 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3465 DEC_PYCALLBACK__(StartingClick);
3466 DEC_PYCALLBACK__(Destroy);
3467 DEC_PYCALLBACK__STRING(SetParameters);
3468 DEC_PYCALLBACK_STRING__constpure(GetValue);
3469
3470 PYPRIVATE;
3471 };
3472
3473
3474 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3475 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3476 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3477 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3478 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3479 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3480 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3481 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3482 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3483
3484
3485 static const wxString wxPyOneString(_T("1"));
3486 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3487 if (!self->GetClientObject())
3488 self->SetClientObject(new wxPyOORClientData(_self));
3489 }
3490 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3491 }
3492 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3493 if (!self->GetClientObject())
3494 self->SetClientObject(new wxPyOORClientData(_self));
3495 }
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERNINLINE int
3511 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3515 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3516 return res;
3517 }
3518
3519
3520 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3521 {
3522 public:
3523 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3524
3525 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3526 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3527 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3528 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3529
3530 PYPRIVATE;
3531 };
3532
3533 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3534 if (!self->GetClientObject())
3535 self->SetClientObject(new wxPyOORClientData(_self));
3536 }
3537
3538 #define SWIG_From_double PyFloat_FromDouble
3539
3540
3541 SWIGINTERN int
3542 SWIG_AsVal_double (PyObject *obj, double* val)
3543 {
3544 if (PyNumber_Check(obj)) {
3545 if (val) *val = PyFloat_AsDouble(obj);
3546 return SWIG_OK;
3547 }
3548 return SWIG_TypeError;
3549 }
3550
3551
3552 class wxPyGridTableBase : public wxGridTableBase
3553 {
3554 public:
3555 wxPyGridTableBase() : wxGridTableBase() {}
3556
3557 PYCALLBACK_INT__pure(GetNumberRows);
3558 PYCALLBACK_INT__pure(GetNumberCols);
3559 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3560 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3561 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3562 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3563 PYCALLBACK__(wxGridTableBase, Clear);
3564 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3565 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3566 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3567 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3568 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3569 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3570 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3571 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3572 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3573 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3574 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3575 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3576 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3577 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3578 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3579
3580
3581 wxString GetValue(int row, int col) {
3582 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3583 wxString rval;
3584 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3585 PyObject* ro;
3586 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3587 if (ro) {
3588 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3589 PyObject* old = ro;
3590 ro = PyObject_Str(ro);
3591 Py_DECREF(old);
3592 }
3593 rval = Py2wxString(ro);
3594 Py_DECREF(ro);
3595 }
3596 }
3597 wxPyEndBlockThreads(blocked);
3598 return rval;
3599 }
3600
3601 void SetValue(int row, int col, const wxString& val) {
3602 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3603 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3604 PyObject* s = wx2PyString(val);
3605 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3606 Py_DECREF(s);
3607 }
3608 wxPyEndBlockThreads(blocked);
3609 }
3610
3611
3612 // Map the Get/Set methods for the standard non-string types to
3613 // the GetValue and SetValue python methods.
3614 long GetValueAsLong( int row, int col ) {
3615 long rval = 0;
3616 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3617 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3618 PyObject* ro;
3619 PyObject* num;
3620 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3621 if (ro && PyNumber_Check(ro)) {
3622 num = PyNumber_Int(ro);
3623 if (num) {
3624 rval = PyInt_AsLong(num);
3625 Py_DECREF(num);
3626 }
3627 Py_DECREF(ro);
3628 }
3629 }
3630 wxPyEndBlockThreads(blocked);
3631 return rval;
3632 }
3633
3634 double GetValueAsDouble( int row, int col ) {
3635 double rval = 0.0;
3636 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3637 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3638 PyObject* ro;
3639 PyObject* num;
3640 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3641 if (ro && PyNumber_Check(ro)) {
3642 num = PyNumber_Float(ro);
3643 if (num) {
3644 rval = PyFloat_AsDouble(num);
3645 Py_DECREF(num);
3646 }
3647 Py_DECREF(ro);
3648 }
3649 }
3650 wxPyEndBlockThreads(blocked);
3651 return rval;
3652 }
3653
3654 bool GetValueAsBool( int row, int col ) {
3655 return (bool)GetValueAsLong(row, col);
3656 }
3657
3658 void SetValueAsLong( int row, int col, long value ) {
3659 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3660 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3661 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3662 }
3663 wxPyEndBlockThreads(blocked);
3664 }
3665
3666 void SetValueAsDouble( int row, int col, double value ) {
3667 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3668 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3669 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3670 }
3671 wxPyEndBlockThreads(blocked);
3672 }
3673
3674 void SetValueAsBool( int row, int col, bool value ) {
3675 SetValueAsLong( row, col, (long)value );
3676 }
3677
3678
3679 PYPRIVATE;
3680 };
3681
3682 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3683
3684 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3685
3686 if (source == Py_None) {
3687 **obj = wxGridCellCoords(-1,-1);
3688 return true;
3689 }
3690
3691 // If source is an object instance then it may already be the right type
3692 if (wxPySwigInstance_Check(source)) {
3693 wxGridCellCoords* ptr;
3694 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3695 goto error;
3696 *obj = ptr;
3697 return true;
3698 }
3699 // otherwise a 2-tuple of integers is expected
3700 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3701 PyObject* o1 = PySequence_GetItem(source, 0);
3702 PyObject* o2 = PySequence_GetItem(source, 1);
3703 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3704 Py_DECREF(o1);
3705 Py_DECREF(o2);
3706 goto error;
3707 }
3708 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3709 Py_DECREF(o1);
3710 Py_DECREF(o2);
3711 return true;
3712 }
3713
3714 error:
3715 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3716 return false;
3717 }
3718
3719
3720 bool wxGridCellCoords_typecheck(PyObject* source) {
3721 void* ptr;
3722
3723 if (wxPySwigInstance_Check(source) &&
3724 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3725 return true;
3726
3727 PyErr_Clear();
3728 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3729 return true;
3730
3731 return false;
3732 }
3733
3734
3735 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3736 {
3737 PyObject* list = PyList_New(0);
3738 size_t idx;
3739 for (idx = 0; idx < source.GetCount(); idx += 1) {
3740 wxGridCellCoords& coord = source.Item(idx);
3741 PyObject* tup = PyTuple_New(2);
3742 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3743 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3744 PyList_Append(list, tup);
3745 Py_DECREF(tup);
3746 }
3747 return list;
3748 }
3749
3750 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3751 wxGridCellCoords temp, *obj = &temp;
3752 if ( other == Py_None ) return false;
3753 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3754 PyErr_Clear();
3755 return false;
3756 }
3757 return self->operator==(*obj);
3758 }
3759 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3760 wxGridCellCoords temp, *obj = &temp;
3761 if ( other == Py_None ) return true;
3762 if ( ! wxGridCellCoords_helper(other, &obj)) {
3763 PyErr_Clear();
3764 return true;
3765 }
3766 return self->operator!=(*obj);
3767 }
3768 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3769 PyObject* tup = PyTuple_New(2);
3770 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3771 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3772 return tup;
3773 }
3774
3775 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3776
3777 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3778 wxGridCellCoords rv;
3779 self->XYToCell(x, y, rv);
3780 return rv;
3781 }
3782 #ifdef __cplusplus
3783 extern "C" {
3784 #endif
3785 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3786 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3787 return 1;
3788 }
3789
3790
3791 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3792 PyObject *pyobj = 0;
3793
3794 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3795 return pyobj;
3796 }
3797
3798
3799 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3800 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3801 return 1;
3802 }
3803
3804
3805 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3806 PyObject *pyobj = 0;
3807
3808 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3809 return pyobj;
3810 }
3811
3812
3813 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj = 0;
3815 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3816 PyObject *arg2 = (PyObject *) 0 ;
3817 void *argp1 = 0 ;
3818 int res1 = 0 ;
3819 PyObject * obj0 = 0 ;
3820 PyObject * obj1 = 0 ;
3821 char * kwnames[] = {
3822 (char *) "self",(char *) "_self", NULL
3823 };
3824
3825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3827 if (!SWIG_IsOK(res1)) {
3828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3829 }
3830 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3831 arg2 = obj1;
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 wxGridCellWorker__setOORInfo(arg1,arg2);
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_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3846 PyObject *resultobj = 0;
3847 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3848 void *argp1 = 0 ;
3849 int res1 = 0 ;
3850 PyObject *swig_obj[1] ;
3851
3852 if (!args) SWIG_fail;
3853 swig_obj[0] = args;
3854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3855 if (!SWIG_IsOK(res1)) {
3856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3857 }
3858 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 delete_wxGridCellWorker(arg1);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 resultobj = SWIG_Py_Void();
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj = 0;
3875 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3876 wxString *arg2 = 0 ;
3877 void *argp1 = 0 ;
3878 int res1 = 0 ;
3879 bool temp2 = false ;
3880 PyObject * obj0 = 0 ;
3881 PyObject * obj1 = 0 ;
3882 char * kwnames[] = {
3883 (char *) "self",(char *) "params", NULL
3884 };
3885
3886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3888 if (!SWIG_IsOK(res1)) {
3889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3890 }
3891 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3892 {
3893 arg2 = wxString_in_helper(obj1);
3894 if (arg2 == NULL) SWIG_fail;
3895 temp2 = true;
3896 }
3897 {
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 (arg1)->SetParameters((wxString const &)*arg2);
3900 wxPyEndAllowThreads(__tstate);
3901 if (PyErr_Occurred()) SWIG_fail;
3902 }
3903 resultobj = SWIG_Py_Void();
3904 {
3905 if (temp2)
3906 delete arg2;
3907 }
3908 return resultobj;
3909 fail:
3910 {
3911 if (temp2)
3912 delete arg2;
3913 }
3914 return NULL;
3915 }
3916
3917
3918 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3919 PyObject *resultobj = 0;
3920 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3921 void *argp1 = 0 ;
3922 int res1 = 0 ;
3923 PyObject *swig_obj[1] ;
3924
3925 if (!args) SWIG_fail;
3926 swig_obj[0] = args;
3927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3928 if (!SWIG_IsOK(res1)) {
3929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3930 }
3931 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3932 {
3933 PyThreadState* __tstate = wxPyBeginAllowThreads();
3934 (arg1)->IncRef();
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 resultobj = SWIG_Py_Void();
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3946 PyObject *resultobj = 0;
3947 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3948 void *argp1 = 0 ;
3949 int res1 = 0 ;
3950 PyObject *swig_obj[1] ;
3951
3952 if (!args) SWIG_fail;
3953 swig_obj[0] = args;
3954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3955 if (!SWIG_IsOK(res1)) {
3956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3957 }
3958 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3959 {
3960 PyThreadState* __tstate = wxPyBeginAllowThreads();
3961 (arg1)->DecRef();
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 resultobj = SWIG_Py_Void();
3966 return resultobj;
3967 fail:
3968 return NULL;
3969 }
3970
3971
3972 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3973 PyObject *obj;
3974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3975 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3976 return SWIG_Py_Void();
3977 }
3978
3979 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj = 0;
3981 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3982 wxGrid *arg2 = 0 ;
3983 wxGridCellAttr *arg3 = 0 ;
3984 wxDC *arg4 = 0 ;
3985 wxRect *arg5 = 0 ;
3986 int arg6 ;
3987 int arg7 ;
3988 bool arg8 ;
3989 void *argp1 = 0 ;
3990 int res1 = 0 ;
3991 void *argp2 = 0 ;
3992 int res2 = 0 ;
3993 void *argp3 = 0 ;
3994 int res3 = 0 ;
3995 void *argp4 = 0 ;
3996 int res4 = 0 ;
3997 wxRect temp5 ;
3998 int val6 ;
3999 int ecode6 = 0 ;
4000 int val7 ;
4001 int ecode7 = 0 ;
4002 bool val8 ;
4003 int ecode8 = 0 ;
4004 PyObject * obj0 = 0 ;
4005 PyObject * obj1 = 0 ;
4006 PyObject * obj2 = 0 ;
4007 PyObject * obj3 = 0 ;
4008 PyObject * obj4 = 0 ;
4009 PyObject * obj5 = 0 ;
4010 PyObject * obj6 = 0 ;
4011 PyObject * obj7 = 0 ;
4012 char * kwnames[] = {
4013 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4014 };
4015
4016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4018 if (!SWIG_IsOK(res1)) {
4019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4020 }
4021 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4023 if (!SWIG_IsOK(res2)) {
4024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4025 }
4026 if (!argp2) {
4027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4028 }
4029 arg2 = reinterpret_cast< wxGrid * >(argp2);
4030 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4031 if (!SWIG_IsOK(res3)) {
4032 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4033 }
4034 if (!argp3) {
4035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4036 }
4037 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4038 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4039 if (!SWIG_IsOK(res4)) {
4040 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4041 }
4042 if (!argp4) {
4043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4044 }
4045 arg4 = reinterpret_cast< wxDC * >(argp4);
4046 {
4047 arg5 = &temp5;
4048 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4049 }
4050 ecode6 = SWIG_AsVal_int(obj5, &val6);
4051 if (!SWIG_IsOK(ecode6)) {
4052 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4053 }
4054 arg6 = static_cast< int >(val6);
4055 ecode7 = SWIG_AsVal_int(obj6, &val7);
4056 if (!SWIG_IsOK(ecode7)) {
4057 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4058 }
4059 arg7 = static_cast< int >(val7);
4060 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4061 if (!SWIG_IsOK(ecode8)) {
4062 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4063 }
4064 arg8 = static_cast< bool >(val8);
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4068 wxPyEndAllowThreads(__tstate);
4069 if (PyErr_Occurred()) SWIG_fail;
4070 }
4071 resultobj = SWIG_Py_Void();
4072 return resultobj;
4073 fail:
4074 return NULL;
4075 }
4076
4077
4078 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4079 PyObject *resultobj = 0;
4080 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4081 wxGrid *arg2 = 0 ;
4082 wxGridCellAttr *arg3 = 0 ;
4083 wxDC *arg4 = 0 ;
4084 int arg5 ;
4085 int arg6 ;
4086 wxSize result;
4087 void *argp1 = 0 ;
4088 int res1 = 0 ;
4089 void *argp2 = 0 ;
4090 int res2 = 0 ;
4091 void *argp3 = 0 ;
4092 int res3 = 0 ;
4093 void *argp4 = 0 ;
4094 int res4 = 0 ;
4095 int val5 ;
4096 int ecode5 = 0 ;
4097 int val6 ;
4098 int ecode6 = 0 ;
4099 PyObject * obj0 = 0 ;
4100 PyObject * obj1 = 0 ;
4101 PyObject * obj2 = 0 ;
4102 PyObject * obj3 = 0 ;
4103 PyObject * obj4 = 0 ;
4104 PyObject * obj5 = 0 ;
4105 char * kwnames[] = {
4106 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4107 };
4108
4109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4111 if (!SWIG_IsOK(res1)) {
4112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4113 }
4114 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4116 if (!SWIG_IsOK(res2)) {
4117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4118 }
4119 if (!argp2) {
4120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4121 }
4122 arg2 = reinterpret_cast< wxGrid * >(argp2);
4123 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4124 if (!SWIG_IsOK(res3)) {
4125 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4126 }
4127 if (!argp3) {
4128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4129 }
4130 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4131 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4132 if (!SWIG_IsOK(res4)) {
4133 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4134 }
4135 if (!argp4) {
4136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4137 }
4138 arg4 = reinterpret_cast< wxDC * >(argp4);
4139 ecode5 = SWIG_AsVal_int(obj4, &val5);
4140 if (!SWIG_IsOK(ecode5)) {
4141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4142 }
4143 arg5 = static_cast< int >(val5);
4144 ecode6 = SWIG_AsVal_int(obj5, &val6);
4145 if (!SWIG_IsOK(ecode6)) {
4146 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4147 }
4148 arg6 = static_cast< int >(val6);
4149 {
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4163 PyObject *resultobj = 0;
4164 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4165 wxGridCellRenderer *result = 0 ;
4166 void *argp1 = 0 ;
4167 int res1 = 0 ;
4168 PyObject *swig_obj[1] ;
4169
4170 if (!args) SWIG_fail;
4171 swig_obj[0] = args;
4172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4173 if (!SWIG_IsOK(res1)) {
4174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4175 }
4176 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4177 {
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 {
4184 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4185 }
4186 return resultobj;
4187 fail:
4188 return NULL;
4189 }
4190
4191
4192 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4193 PyObject *obj;
4194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4195 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4196 return SWIG_Py_Void();
4197 }
4198
4199 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4200 PyObject *resultobj = 0;
4201 wxPyGridCellRenderer *result = 0 ;
4202
4203 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4204 {
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4207 wxPyEndAllowThreads(__tstate);
4208 if (PyErr_Occurred()) SWIG_fail;
4209 }
4210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4211 return resultobj;
4212 fail:
4213 return NULL;
4214 }
4215
4216
4217 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4218 PyObject *resultobj = 0;
4219 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4220 PyObject *arg2 = (PyObject *) 0 ;
4221 PyObject *arg3 = (PyObject *) 0 ;
4222 void *argp1 = 0 ;
4223 int res1 = 0 ;
4224 PyObject * obj0 = 0 ;
4225 PyObject * obj1 = 0 ;
4226 PyObject * obj2 = 0 ;
4227 char * kwnames[] = {
4228 (char *) "self",(char *) "self",(char *) "_class", NULL
4229 };
4230
4231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4233 if (!SWIG_IsOK(res1)) {
4234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4235 }
4236 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4237 arg2 = obj1;
4238 arg3 = obj2;
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 (arg1)->_setCallbackInfo(arg2,arg3);
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 resultobj = SWIG_Py_Void();
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj = 0;
4254 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4255 wxString *arg2 = 0 ;
4256 void *argp1 = 0 ;
4257 int res1 = 0 ;
4258 bool temp2 = false ;
4259 PyObject * obj0 = 0 ;
4260 PyObject * obj1 = 0 ;
4261 char * kwnames[] = {
4262 (char *) "self",(char *) "params", NULL
4263 };
4264
4265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4267 if (!SWIG_IsOK(res1)) {
4268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4269 }
4270 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4271 {
4272 arg2 = wxString_in_helper(obj1);
4273 if (arg2 == NULL) SWIG_fail;
4274 temp2 = true;
4275 }
4276 {
4277 PyThreadState* __tstate = wxPyBeginAllowThreads();
4278 (arg1)->SetParameters((wxString const &)*arg2);
4279 wxPyEndAllowThreads(__tstate);
4280 if (PyErr_Occurred()) SWIG_fail;
4281 }
4282 resultobj = SWIG_Py_Void();
4283 {
4284 if (temp2)
4285 delete arg2;
4286 }
4287 return resultobj;
4288 fail:
4289 {
4290 if (temp2)
4291 delete arg2;
4292 }
4293 return NULL;
4294 }
4295
4296
4297 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4298 PyObject *obj;
4299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4300 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4301 return SWIG_Py_Void();
4302 }
4303
4304 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305 return SWIG_Python_InitShadowInstance(args);
4306 }
4307
4308 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 wxGridCellStringRenderer *result = 0 ;
4311
4312 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4327 PyObject *obj;
4328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4329 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4330 return SWIG_Py_Void();
4331 }
4332
4333 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4334 return SWIG_Python_InitShadowInstance(args);
4335 }
4336
4337 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4338 PyObject *resultobj = 0;
4339 wxGridCellNumberRenderer *result = 0 ;
4340
4341 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4342 {
4343 PyThreadState* __tstate = wxPyBeginAllowThreads();
4344 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4345 wxPyEndAllowThreads(__tstate);
4346 if (PyErr_Occurred()) SWIG_fail;
4347 }
4348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4356 PyObject *obj;
4357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4358 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4359 return SWIG_Py_Void();
4360 }
4361
4362 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4363 return SWIG_Python_InitShadowInstance(args);
4364 }
4365
4366 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj = 0;
4368 int arg1 = (int) -1 ;
4369 int arg2 = (int) -1 ;
4370 wxGridCellFloatRenderer *result = 0 ;
4371 int val1 ;
4372 int ecode1 = 0 ;
4373 int val2 ;
4374 int ecode2 = 0 ;
4375 PyObject * obj0 = 0 ;
4376 PyObject * obj1 = 0 ;
4377 char * kwnames[] = {
4378 (char *) "width",(char *) "precision", NULL
4379 };
4380
4381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4382 if (obj0) {
4383 ecode1 = SWIG_AsVal_int(obj0, &val1);
4384 if (!SWIG_IsOK(ecode1)) {
4385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4386 }
4387 arg1 = static_cast< int >(val1);
4388 }
4389 if (obj1) {
4390 ecode2 = SWIG_AsVal_int(obj1, &val2);
4391 if (!SWIG_IsOK(ecode2)) {
4392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4393 }
4394 arg2 = static_cast< int >(val2);
4395 }
4396 {
4397 PyThreadState* __tstate = wxPyBeginAllowThreads();
4398 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4399 wxPyEndAllowThreads(__tstate);
4400 if (PyErr_Occurred()) SWIG_fail;
4401 }
4402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4403 return resultobj;
4404 fail:
4405 return NULL;
4406 }
4407
4408
4409 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4410 PyObject *resultobj = 0;
4411 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4412 int result;
4413 void *argp1 = 0 ;
4414 int res1 = 0 ;
4415 PyObject *swig_obj[1] ;
4416
4417 if (!args) SWIG_fail;
4418 swig_obj[0] = args;
4419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4420 if (!SWIG_IsOK(res1)) {
4421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4422 }
4423 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4424 {
4425 PyThreadState* __tstate = wxPyBeginAllowThreads();
4426 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4427 wxPyEndAllowThreads(__tstate);
4428 if (PyErr_Occurred()) SWIG_fail;
4429 }
4430 resultobj = SWIG_From_int(static_cast< int >(result));
4431 return resultobj;
4432 fail:
4433 return NULL;
4434 }
4435
4436
4437 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4438 PyObject *resultobj = 0;
4439 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4440 int arg2 ;
4441 void *argp1 = 0 ;
4442 int res1 = 0 ;
4443 int val2 ;
4444 int ecode2 = 0 ;
4445 PyObject * obj0 = 0 ;
4446 PyObject * obj1 = 0 ;
4447 char * kwnames[] = {
4448 (char *) "self",(char *) "width", NULL
4449 };
4450
4451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4453 if (!SWIG_IsOK(res1)) {
4454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4455 }
4456 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4457 ecode2 = SWIG_AsVal_int(obj1, &val2);
4458 if (!SWIG_IsOK(ecode2)) {
4459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4460 }
4461 arg2 = static_cast< int >(val2);
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 (arg1)->SetWidth(arg2);
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4478 int result;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4488 }
4489 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 resultobj = SWIG_From_int(static_cast< int >(result));
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = 0;
4505 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4506 int arg2 ;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 int val2 ;
4510 int ecode2 = 0 ;
4511 PyObject * obj0 = 0 ;
4512 PyObject * obj1 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "self",(char *) "precision", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4519 if (!SWIG_IsOK(res1)) {
4520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4521 }
4522 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4523 ecode2 = SWIG_AsVal_int(obj1, &val2);
4524 if (!SWIG_IsOK(ecode2)) {
4525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4526 }
4527 arg2 = static_cast< int >(val2);
4528 {
4529 PyThreadState* __tstate = wxPyBeginAllowThreads();
4530 (arg1)->SetPrecision(arg2);
4531 wxPyEndAllowThreads(__tstate);
4532 if (PyErr_Occurred()) SWIG_fail;
4533 }
4534 resultobj = SWIG_Py_Void();
4535 return resultobj;
4536 fail:
4537 return NULL;
4538 }
4539
4540
4541 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4542 PyObject *obj;
4543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4544 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4545 return SWIG_Py_Void();
4546 }
4547
4548 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 return SWIG_Python_InitShadowInstance(args);
4550 }
4551
4552 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4553 PyObject *resultobj = 0;
4554 wxGridCellBoolRenderer *result = 0 ;
4555
4556 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4564 return resultobj;
4565 fail:
4566 return NULL;
4567 }
4568
4569
4570 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571 PyObject *obj;
4572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4573 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4574 return SWIG_Py_Void();
4575 }
4576
4577 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4578 return SWIG_Python_InitShadowInstance(args);
4579 }
4580
4581 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4582 PyObject *resultobj = 0;
4583 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4584 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4585 wxGridCellDateTimeRenderer *result = 0 ;
4586 PyObject * obj0 = 0 ;
4587 PyObject * obj1 = 0 ;
4588 char * kwnames[] = {
4589 (char *) "outformat",(char *) "informat", NULL
4590 };
4591
4592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4593 if (obj0) {
4594 {
4595 wxString* sptr = wxString_in_helper(obj0);
4596 if (sptr == NULL) SWIG_fail;
4597 arg1 = *sptr;
4598 delete sptr;
4599 }
4600 }
4601 if (obj1) {
4602 {
4603 wxString* sptr = wxString_in_helper(obj1);
4604 if (sptr == NULL) SWIG_fail;
4605 arg2 = *sptr;
4606 delete sptr;
4607 }
4608 }
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *obj;
4624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4625 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4626 return SWIG_Py_Void();
4627 }
4628
4629 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 return SWIG_Python_InitShadowInstance(args);
4631 }
4632
4633 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4634 PyObject *resultobj = 0;
4635 wxString const &arg1_defvalue = wxPyEmptyString ;
4636 wxString *arg1 = (wxString *) &arg1_defvalue ;
4637 wxGridCellEnumRenderer *result = 0 ;
4638 bool temp1 = false ;
4639 PyObject * obj0 = 0 ;
4640 char * kwnames[] = {
4641 (char *) "choices", NULL
4642 };
4643
4644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4645 if (obj0) {
4646 {
4647 arg1 = wxString_in_helper(obj0);
4648 if (arg1 == NULL) SWIG_fail;
4649 temp1 = true;
4650 }
4651 }
4652 {
4653 PyThreadState* __tstate = wxPyBeginAllowThreads();
4654 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4655 wxPyEndAllowThreads(__tstate);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4659 {
4660 if (temp1)
4661 delete arg1;
4662 }
4663 return resultobj;
4664 fail:
4665 {
4666 if (temp1)
4667 delete arg1;
4668 }
4669 return NULL;
4670 }
4671
4672
4673 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4674 PyObject *obj;
4675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4676 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4677 return SWIG_Py_Void();
4678 }
4679
4680 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 return SWIG_Python_InitShadowInstance(args);
4682 }
4683
4684 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4685 PyObject *resultobj = 0;
4686 wxGridCellAutoWrapStringRenderer *result = 0 ;
4687
4688 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4689 {
4690 PyThreadState* __tstate = wxPyBeginAllowThreads();
4691 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4692 wxPyEndAllowThreads(__tstate);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4696 return resultobj;
4697 fail:
4698 return NULL;
4699 }
4700
4701
4702 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4703 PyObject *obj;
4704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4705 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4706 return SWIG_Py_Void();
4707 }
4708
4709 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4710 return SWIG_Python_InitShadowInstance(args);
4711 }
4712
4713 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4714 PyObject *resultobj = 0;
4715 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4716 bool result;
4717 void *argp1 = 0 ;
4718 int res1 = 0 ;
4719 PyObject *swig_obj[1] ;
4720
4721 if (!args) SWIG_fail;
4722 swig_obj[0] = args;
4723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4726 }
4727 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (bool)(arg1)->IsCreated();
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 {
4735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4736 }
4737 return resultobj;
4738 fail:
4739 return NULL;
4740 }
4741
4742
4743 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4744 PyObject *resultobj = 0;
4745 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4746 wxControl *result = 0 ;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 PyObject *swig_obj[1] ;
4750
4751 if (!args) SWIG_fail;
4752 swig_obj[0] = args;
4753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4754 if (!SWIG_IsOK(res1)) {
4755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4756 }
4757 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 result = (wxControl *)(arg1)->GetControl();
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 {
4765 resultobj = wxPyMake_wxObject(result, 0);
4766 }
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4776 wxControl *arg2 = (wxControl *) 0 ;
4777 void *argp1 = 0 ;
4778 int res1 = 0 ;
4779 void *argp2 = 0 ;
4780 int res2 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "control", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4791 }
4792 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4794 if (!SWIG_IsOK(res2)) {
4795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4796 }
4797 arg2 = reinterpret_cast< wxControl * >(argp2);
4798 {
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 (arg1)->SetControl(arg2);
4801 wxPyEndAllowThreads(__tstate);
4802 if (PyErr_Occurred()) SWIG_fail;
4803 }
4804 resultobj = SWIG_Py_Void();
4805 return resultobj;
4806 fail:
4807 return NULL;
4808 }
4809
4810
4811 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4812 PyObject *resultobj = 0;
4813 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4814 wxGridCellAttr *result = 0 ;
4815 void *argp1 = 0 ;
4816 int res1 = 0 ;
4817 PyObject *swig_obj[1] ;
4818
4819 if (!args) SWIG_fail;
4820 swig_obj[0] = args;
4821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4822 if (!SWIG_IsOK(res1)) {
4823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4824 }
4825 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 {
4833 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4834 }
4835 return resultobj;
4836 fail:
4837 return NULL;
4838 }
4839
4840
4841 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4842 PyObject *resultobj = 0;
4843 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4844 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4845 void *argp1 = 0 ;
4846 int res1 = 0 ;
4847 void *argp2 = 0 ;
4848 int res2 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 char * kwnames[] = {
4852 (char *) "self",(char *) "attr", NULL
4853 };
4854
4855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4857 if (!SWIG_IsOK(res1)) {
4858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4859 }
4860 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4862 if (!SWIG_IsOK(res2)) {
4863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4864 }
4865 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4866 {
4867 PyThreadState* __tstate = wxPyBeginAllowThreads();
4868 (arg1)->SetCellAttr(arg2);
4869 wxPyEndAllowThreads(__tstate);
4870 if (PyErr_Occurred()) SWIG_fail;
4871 }
4872 resultobj = SWIG_Py_Void();
4873 return resultobj;
4874 fail:
4875 return NULL;
4876 }
4877
4878
4879 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4880 PyObject *resultobj = 0;
4881 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4882 wxWindow *arg2 = (wxWindow *) 0 ;
4883 int arg3 ;
4884 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4885 void *argp1 = 0 ;
4886 int res1 = 0 ;
4887 void *argp2 = 0 ;
4888 int res2 = 0 ;
4889 int val3 ;
4890 int ecode3 = 0 ;
4891 void *argp4 = 0 ;
4892 int res4 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 PyObject * obj2 = 0 ;
4896 PyObject * obj3 = 0 ;
4897 char * kwnames[] = {
4898 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4899 };
4900
4901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4903 if (!SWIG_IsOK(res1)) {
4904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4905 }
4906 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4908 if (!SWIG_IsOK(res2)) {
4909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4910 }
4911 arg2 = reinterpret_cast< wxWindow * >(argp2);
4912 ecode3 = SWIG_AsVal_int(obj2, &val3);
4913 if (!SWIG_IsOK(ecode3)) {
4914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4915 }
4916 arg3 = static_cast< int >(val3);
4917 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4918 if (!SWIG_IsOK(res4)) {
4919 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4920 }
4921 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 (arg1)->Create(arg2,arg3,arg4);
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 resultobj = SWIG_Py_Void();
4929 return resultobj;
4930 fail:
4931 return NULL;
4932 }
4933
4934
4935 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj = 0;
4937 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4938 int arg2 ;
4939 int arg3 ;
4940 wxGrid *arg4 = (wxGrid *) 0 ;
4941 void *argp1 = 0 ;
4942 int res1 = 0 ;
4943 int val2 ;
4944 int ecode2 = 0 ;
4945 int val3 ;
4946 int ecode3 = 0 ;
4947 void *argp4 = 0 ;
4948 int res4 = 0 ;
4949 PyObject * obj0 = 0 ;
4950 PyObject * obj1 = 0 ;
4951 PyObject * obj2 = 0 ;
4952 PyObject * obj3 = 0 ;
4953 char * kwnames[] = {
4954 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4955 };
4956
4957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4959 if (!SWIG_IsOK(res1)) {
4960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4961 }
4962 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4963 ecode2 = SWIG_AsVal_int(obj1, &val2);
4964 if (!SWIG_IsOK(ecode2)) {
4965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4966 }
4967 arg2 = static_cast< int >(val2);
4968 ecode3 = SWIG_AsVal_int(obj2, &val3);
4969 if (!SWIG_IsOK(ecode3)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4971 }
4972 arg3 = static_cast< int >(val3);
4973 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4974 if (!SWIG_IsOK(res4)) {
4975 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4976 }
4977 arg4 = reinterpret_cast< wxGrid * >(argp4);
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 (arg1)->BeginEdit(arg2,arg3,arg4);
4981 wxPyEndAllowThreads(__tstate);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_Py_Void();
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj = 0;
4993 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4994 int arg2 ;
4995 int arg3 ;
4996 wxGrid *arg4 = (wxGrid *) 0 ;
4997 bool result;
4998 void *argp1 = 0 ;
4999 int res1 = 0 ;
5000 int val2 ;
5001 int ecode2 = 0 ;
5002 int val3 ;
5003 int ecode3 = 0 ;
5004 void *argp4 = 0 ;
5005 int res4 = 0 ;
5006 PyObject * obj0 = 0 ;
5007 PyObject * obj1 = 0 ;
5008 PyObject * obj2 = 0 ;
5009 PyObject * obj3 = 0 ;
5010 char * kwnames[] = {
5011 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5012 };
5013
5014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5016 if (!SWIG_IsOK(res1)) {
5017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5018 }
5019 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5020 ecode2 = SWIG_AsVal_int(obj1, &val2);
5021 if (!SWIG_IsOK(ecode2)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5023 }
5024 arg2 = static_cast< int >(val2);
5025 ecode3 = SWIG_AsVal_int(obj2, &val3);
5026 if (!SWIG_IsOK(ecode3)) {
5027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5028 }
5029 arg3 = static_cast< int >(val3);
5030 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5031 if (!SWIG_IsOK(res4)) {
5032 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5033 }
5034 arg4 = reinterpret_cast< wxGrid * >(argp4);
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 {
5042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5043 }
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5051 PyObject *resultobj = 0;
5052 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 PyObject *swig_obj[1] ;
5056
5057 if (!args) SWIG_fail;
5058 swig_obj[0] = args;
5059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5062 }
5063 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 (arg1)->Reset();
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_Py_Void();
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5078 PyObject *resultobj = 0;
5079 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5080 wxGridCellEditor *result = 0 ;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 PyObject *swig_obj[1] ;
5084
5085 if (!args) SWIG_fail;
5086 swig_obj[0] = args;
5087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5088 if (!SWIG_IsOK(res1)) {
5089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5090 }
5091 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5100 }
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5108 PyObject *resultobj = 0;
5109 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5110 wxRect *arg2 = 0 ;
5111 void *argp1 = 0 ;
5112 int res1 = 0 ;
5113 wxRect temp2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char * kwnames[] = {
5117 (char *) "self",(char *) "rect", NULL
5118 };
5119
5120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5122 if (!SWIG_IsOK(res1)) {
5123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5124 }
5125 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5126 {
5127 arg2 = &temp2;
5128 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetSize((wxRect const &)*arg2);
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 resultobj = SWIG_Py_Void();
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj = 0;
5145 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5146 bool arg2 ;
5147 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5148 void *argp1 = 0 ;
5149 int res1 = 0 ;
5150 bool val2 ;
5151 int ecode2 = 0 ;
5152 void *argp3 = 0 ;
5153 int res3 = 0 ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 PyObject * obj2 = 0 ;
5157 char * kwnames[] = {
5158 (char *) "self",(char *) "show",(char *) "attr", NULL
5159 };
5160
5161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5163 if (!SWIG_IsOK(res1)) {
5164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5165 }
5166 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5168 if (!SWIG_IsOK(ecode2)) {
5169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5170 }
5171 arg2 = static_cast< bool >(val2);
5172 if (obj2) {
5173 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5174 if (!SWIG_IsOK(res3)) {
5175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5176 }
5177 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5178 }
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 (arg1)->Show(arg2,arg3);
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_Py_Void();
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5195 wxRect *arg2 = 0 ;
5196 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5197 void *argp1 = 0 ;
5198 int res1 = 0 ;
5199 wxRect temp2 ;
5200 void *argp3 = 0 ;
5201 int res3 = 0 ;
5202 PyObject * obj0 = 0 ;
5203 PyObject * obj1 = 0 ;
5204 PyObject * obj2 = 0 ;
5205 char * kwnames[] = {
5206 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5207 };
5208
5209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5211 if (!SWIG_IsOK(res1)) {
5212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5213 }
5214 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5215 {
5216 arg2 = &temp2;
5217 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5218 }
5219 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5220 if (!SWIG_IsOK(res3)) {
5221 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5222 }
5223 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5224 {
5225 PyThreadState* __tstate = wxPyBeginAllowThreads();
5226 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5227 wxPyEndAllowThreads(__tstate);
5228 if (PyErr_Occurred()) SWIG_fail;
5229 }
5230 resultobj = SWIG_Py_Void();
5231 return resultobj;
5232 fail:
5233 return NULL;
5234 }
5235
5236
5237 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5238 PyObject *resultobj = 0;
5239 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5240 wxKeyEvent *arg2 = 0 ;
5241 bool result;
5242 void *argp1 = 0 ;
5243 int res1 = 0 ;
5244 void *argp2 = 0 ;
5245 int res2 = 0 ;
5246 PyObject * obj0 = 0 ;
5247 PyObject * obj1 = 0 ;
5248 char * kwnames[] = {
5249 (char *) "self",(char *) "event", NULL
5250 };
5251
5252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5254 if (!SWIG_IsOK(res1)) {
5255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5256 }
5257 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5258 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5259 if (!SWIG_IsOK(res2)) {
5260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5261 }
5262 if (!argp2) {
5263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5264 }
5265 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5274 }
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj = 0;
5283 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5284 wxKeyEvent *arg2 = 0 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 void *argp2 = 0 ;
5288 int res2 = 0 ;
5289 PyObject * obj0 = 0 ;
5290 PyObject * obj1 = 0 ;
5291 char * kwnames[] = {
5292 (char *) "self",(char *) "event", NULL
5293 };
5294
5295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5297 if (!SWIG_IsOK(res1)) {
5298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5299 }
5300 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5301 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5302 if (!SWIG_IsOK(res2)) {
5303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5304 }
5305 if (!argp2) {
5306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5307 }
5308 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5309 {
5310 PyThreadState* __tstate = wxPyBeginAllowThreads();
5311 (arg1)->StartingKey(*arg2);
5312 wxPyEndAllowThreads(__tstate);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 resultobj = SWIG_Py_Void();
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5323 PyObject *resultobj = 0;
5324 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5325 void *argp1 = 0 ;
5326 int res1 = 0 ;
5327 PyObject *swig_obj[1] ;
5328
5329 if (!args) SWIG_fail;
5330 swig_obj[0] = args;
5331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5332 if (!SWIG_IsOK(res1)) {
5333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5334 }
5335 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 (arg1)->StartingClick();
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_Py_Void();
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5352 wxKeyEvent *arg2 = 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 void *argp2 = 0 ;
5356 int res2 = 0 ;
5357 PyObject * obj0 = 0 ;
5358 PyObject * obj1 = 0 ;
5359 char * kwnames[] = {
5360 (char *) "self",(char *) "event", NULL
5361 };
5362
5363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5365 if (!SWIG_IsOK(res1)) {
5366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5367 }
5368 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5370 if (!SWIG_IsOK(res2)) {
5371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5372 }
5373 if (!argp2) {
5374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5375 }
5376 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 (arg1)->HandleReturn(*arg2);
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 resultobj = SWIG_Py_Void();
5384 return resultobj;
5385 fail:
5386 return NULL;
5387 }
5388
5389
5390 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5391 PyObject *resultobj = 0;
5392 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5393 void *argp1 = 0 ;
5394 int res1 = 0 ;
5395 PyObject *swig_obj[1] ;
5396
5397 if (!args) SWIG_fail;
5398 swig_obj[0] = args;
5399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5400 if (!SWIG_IsOK(res1)) {
5401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5402 }
5403 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 (arg1)->Destroy();
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 resultobj = SWIG_Py_Void();
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *obj;
5419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5420 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5421 return SWIG_Py_Void();
5422 }
5423
5424 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *resultobj = 0;
5426 wxPyGridCellEditor *result = 0 ;
5427
5428 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5429 {
5430 PyThreadState* __tstate = wxPyBeginAllowThreads();
5431 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5436 return resultobj;
5437 fail:
5438 return NULL;
5439 }
5440
5441
5442 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5443 PyObject *resultobj = 0;
5444 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5445 PyObject *arg2 = (PyObject *) 0 ;
5446 PyObject *arg3 = (PyObject *) 0 ;
5447 void *argp1 = 0 ;
5448 int res1 = 0 ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 PyObject * obj2 = 0 ;
5452 char * kwnames[] = {
5453 (char *) "self",(char *) "self",(char *) "_class", NULL
5454 };
5455
5456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5458 if (!SWIG_IsOK(res1)) {
5459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5460 }
5461 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5462 arg2 = obj1;
5463 arg3 = obj2;
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 (arg1)->_setCallbackInfo(arg2,arg3);
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 resultobj = SWIG_Py_Void();
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5478 PyObject *resultobj = 0;
5479 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5480 wxString *arg2 = 0 ;
5481 void *argp1 = 0 ;
5482 int res1 = 0 ;
5483 bool temp2 = false ;
5484 PyObject * obj0 = 0 ;
5485 PyObject * obj1 = 0 ;
5486 char * kwnames[] = {
5487 (char *) "self",(char *) "params", NULL
5488 };
5489
5490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5492 if (!SWIG_IsOK(res1)) {
5493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5494 }
5495 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5496 {
5497 arg2 = wxString_in_helper(obj1);
5498 if (arg2 == NULL) SWIG_fail;
5499 temp2 = true;
5500 }
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 (arg1)->SetParameters((wxString const &)*arg2);
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 resultobj = SWIG_Py_Void();
5508 {
5509 if (temp2)
5510 delete arg2;
5511 }
5512 return resultobj;
5513 fail:
5514 {
5515 if (temp2)
5516 delete arg2;
5517 }
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 PyObject *obj;
5524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5525 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5526 return SWIG_Py_Void();
5527 }
5528
5529 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 return SWIG_Python_InitShadowInstance(args);
5531 }
5532
5533 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 PyObject *resultobj = 0;
5535 wxGridCellTextEditor *result = 0 ;
5536
5537 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5538 {
5539 PyThreadState* __tstate = wxPyBeginAllowThreads();
5540 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5541 wxPyEndAllowThreads(__tstate);
5542 if (PyErr_Occurred()) SWIG_fail;
5543 }
5544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5552 PyObject *resultobj = 0;
5553 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5554 wxString result;
5555 void *argp1 = 0 ;
5556 int res1 = 0 ;
5557 PyObject *swig_obj[1] ;
5558
5559 if (!args) SWIG_fail;
5560 swig_obj[0] = args;
5561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5562 if (!SWIG_IsOK(res1)) {
5563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5564 }
5565 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5566 {
5567 PyThreadState* __tstate = wxPyBeginAllowThreads();
5568 result = (arg1)->GetValue();
5569 wxPyEndAllowThreads(__tstate);
5570 if (PyErr_Occurred()) SWIG_fail;
5571 }
5572 {
5573 #if wxUSE_UNICODE
5574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5575 #else
5576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5577 #endif
5578 }
5579 return resultobj;
5580 fail:
5581 return NULL;
5582 }
5583
5584
5585 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *obj;
5587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5588 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5589 return SWIG_Py_Void();
5590 }
5591
5592 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 return SWIG_Python_InitShadowInstance(args);
5594 }
5595
5596 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj = 0;
5598 int arg1 = (int) -1 ;
5599 int arg2 = (int) -1 ;
5600 wxGridCellNumberEditor *result = 0 ;
5601 int val1 ;
5602 int ecode1 = 0 ;
5603 int val2 ;
5604 int ecode2 = 0 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 char * kwnames[] = {
5608 (char *) "min",(char *) "max", NULL
5609 };
5610
5611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5612 if (obj0) {
5613 ecode1 = SWIG_AsVal_int(obj0, &val1);
5614 if (!SWIG_IsOK(ecode1)) {
5615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5616 }
5617 arg1 = static_cast< int >(val1);
5618 }
5619 if (obj1) {
5620 ecode2 = SWIG_AsVal_int(obj1, &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5640 PyObject *obj;
5641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5642 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5643 return SWIG_Py_Void();
5644 }
5645
5646 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5647 return SWIG_Python_InitShadowInstance(args);
5648 }
5649
5650 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj = 0;
5652 int arg1 = (int) -1 ;
5653 int arg2 = (int) -1 ;
5654 wxGridCellFloatEditor *result = 0 ;
5655 int val1 ;
5656 int ecode1 = 0 ;
5657 int val2 ;
5658 int ecode2 = 0 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char * kwnames[] = {
5662 (char *) "width",(char *) "precision", NULL
5663 };
5664
5665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5666 if (obj0) {
5667 ecode1 = SWIG_AsVal_int(obj0, &val1);
5668 if (!SWIG_IsOK(ecode1)) {
5669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5670 }
5671 arg1 = static_cast< int >(val1);
5672 }
5673 if (obj1) {
5674 ecode2 = SWIG_AsVal_int(obj1, &val2);
5675 if (!SWIG_IsOK(ecode2)) {
5676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5677 }
5678 arg2 = static_cast< int >(val2);
5679 }
5680 {
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5683 wxPyEndAllowThreads(__tstate);
5684 if (PyErr_Occurred()) SWIG_fail;
5685 }
5686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5687 return resultobj;
5688 fail:
5689 return NULL;
5690 }
5691
5692
5693 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5694 PyObject *obj;
5695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5696 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5697 return SWIG_Py_Void();
5698 }
5699
5700 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 return SWIG_Python_InitShadowInstance(args);
5702 }
5703
5704 SWIGINTERN int OneString_set(PyObject *) {
5705 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5706 return 1;
5707 }
5708
5709
5710 SWIGINTERN PyObject *OneString_get(void) {
5711 PyObject *pyobj = 0;
5712
5713 {
5714 #if wxUSE_UNICODE
5715 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5716 #else
5717 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5718 #endif
5719 }
5720 return pyobj;
5721 }
5722
5723
5724 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725 PyObject *resultobj = 0;
5726 wxGridCellBoolEditor *result = 0 ;
5727
5728 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5729 {
5730 PyThreadState* __tstate = wxPyBeginAllowThreads();
5731 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5732 wxPyEndAllowThreads(__tstate);
5733 if (PyErr_Occurred()) SWIG_fail;
5734 }
5735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj = 0;
5744 wxString const &arg1_defvalue = wxPyOneString ;
5745 wxString *arg1 = (wxString *) &arg1_defvalue ;
5746 wxString const &arg2_defvalue = wxPyEmptyString ;
5747 wxString *arg2 = (wxString *) &arg2_defvalue ;
5748 bool temp1 = false ;
5749 bool temp2 = false ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 char * kwnames[] = {
5753 (char *) "valueTrue",(char *) "valueFalse", NULL
5754 };
5755
5756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5757 if (obj0) {
5758 {
5759 arg1 = wxString_in_helper(obj0);
5760 if (arg1 == NULL) SWIG_fail;
5761 temp1 = true;
5762 }
5763 }
5764 if (obj1) {
5765 {
5766 arg2 = wxString_in_helper(obj1);
5767 if (arg2 == NULL) SWIG_fail;
5768 temp2 = true;
5769 }
5770 }
5771 {
5772 PyThreadState* __tstate = wxPyBeginAllowThreads();
5773 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_Py_Void();
5778 {
5779 if (temp1)
5780 delete arg1;
5781 }
5782 {
5783 if (temp2)
5784 delete arg2;
5785 }
5786 return resultobj;
5787 fail:
5788 {
5789 if (temp1)
5790 delete arg1;
5791 }
5792 {
5793 if (temp2)
5794 delete arg2;
5795 }
5796 return NULL;
5797 }
5798
5799
5800 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5801 PyObject *resultobj = 0;
5802 wxString *arg1 = 0 ;
5803 bool result;
5804 bool temp1 = false ;
5805 PyObject * obj0 = 0 ;
5806 char * kwnames[] = {
5807 (char *) "value", NULL
5808 };
5809
5810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5811 {
5812 arg1 = wxString_in_helper(obj0);
5813 if (arg1 == NULL) SWIG_fail;
5814 temp1 = true;
5815 }
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5824 }
5825 {
5826 if (temp1)
5827 delete arg1;
5828 }
5829 return resultobj;
5830 fail:
5831 {
5832 if (temp1)
5833 delete arg1;
5834 }
5835 return NULL;
5836 }
5837
5838
5839 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5840 PyObject *obj;
5841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5842 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5843 return SWIG_Py_Void();
5844 }
5845
5846 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5847 return SWIG_Python_InitShadowInstance(args);
5848 }
5849
5850 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5851 PyObject *resultobj = 0;
5852 int arg1 = (int) 0 ;
5853 wxString *arg2 = (wxString *) NULL ;
5854 bool arg3 = (bool) false ;
5855 wxGridCellChoiceEditor *result = 0 ;
5856 bool val3 ;
5857 int ecode3 = 0 ;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 char * kwnames[] = {
5861 (char *) "choices",(char *) "allowOthers", NULL
5862 };
5863
5864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5865 if (obj0) {
5866 {
5867 arg1 = PyList_Size(obj0);
5868 arg2 = wxString_LIST_helper(obj0);
5869 if (arg2 == NULL) SWIG_fail;
5870 }
5871 }
5872 if (obj1) {
5873 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5874 if (!SWIG_IsOK(ecode3)) {
5875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5876 }
5877 arg3 = static_cast< bool >(val3);
5878 }
5879 {
5880 PyThreadState* __tstate = wxPyBeginAllowThreads();
5881 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5882 wxPyEndAllowThreads(__tstate);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5886 {
5887 if (arg2) delete [] arg2;
5888 }
5889 return resultobj;
5890 fail:
5891 {
5892 if (arg2) delete [] arg2;
5893 }
5894 return NULL;
5895 }
5896
5897
5898 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5899 PyObject *obj;
5900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5901 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5902 return SWIG_Py_Void();
5903 }
5904
5905 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5906 return SWIG_Python_InitShadowInstance(args);
5907 }
5908
5909 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = 0;
5911 wxString const &arg1_defvalue = wxPyEmptyString ;
5912 wxString *arg1 = (wxString *) &arg1_defvalue ;
5913 wxGridCellEnumEditor *result = 0 ;
5914 bool temp1 = false ;
5915 PyObject * obj0 = 0 ;
5916 char * kwnames[] = {
5917 (char *) "choices", NULL
5918 };
5919
5920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5921 if (obj0) {
5922 {
5923 arg1 = wxString_in_helper(obj0);
5924 if (arg1 == NULL) SWIG_fail;
5925 temp1 = true;
5926 }
5927 }
5928 {
5929 PyThreadState* __tstate = wxPyBeginAllowThreads();
5930 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5935 {
5936 if (temp1)
5937 delete arg1;
5938 }
5939 return resultobj;
5940 fail:
5941 {
5942 if (temp1)
5943 delete arg1;
5944 }
5945 return NULL;
5946 }
5947
5948
5949 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5950 PyObject *obj;
5951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5952 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5953 return SWIG_Py_Void();
5954 }
5955
5956 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5957 return SWIG_Python_InitShadowInstance(args);
5958 }
5959
5960 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5961 PyObject *resultobj = 0;
5962 wxGridCellAutoWrapStringEditor *result = 0 ;
5963
5964 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5965 {
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5968 wxPyEndAllowThreads(__tstate);
5969 if (PyErr_Occurred()) SWIG_fail;
5970 }
5971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5979 PyObject *obj;
5980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5981 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5982 return SWIG_Py_Void();
5983 }
5984
5985 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5986 return SWIG_Python_InitShadowInstance(args);
5987 }
5988
5989 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5990 PyObject *resultobj = 0;
5991 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5992 PyObject *arg2 = (PyObject *) 0 ;
5993 void *argp1 = 0 ;
5994 int res1 = 0 ;
5995 PyObject * obj0 = 0 ;
5996 PyObject * obj1 = 0 ;
5997 char * kwnames[] = {
5998 (char *) "self",(char *) "_self", NULL
5999 };
6000
6001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",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__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6005 }
6006 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6007 arg2 = obj1;
6008 {
6009 PyThreadState* __tstate = wxPyBeginAllowThreads();
6010 wxGridCellAttr__setOORInfo(arg1,arg2);
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 resultobj = SWIG_Py_Void();
6015 return resultobj;
6016 fail:
6017 return NULL;
6018 }
6019
6020
6021 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6022 PyObject *resultobj = 0;
6023 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6024 wxGridCellAttr *result = 0 ;
6025 void *argp1 = 0 ;
6026 int res1 = 0 ;
6027 PyObject * obj0 = 0 ;
6028 char * kwnames[] = {
6029 (char *) "attrDefault", NULL
6030 };
6031
6032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6033 if (obj0) {
6034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6035 if (!SWIG_IsOK(res1)) {
6036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6037 }
6038 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 {
6047 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6048 }
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6056 PyObject *resultobj = 0;
6057 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6058 void *argp1 = 0 ;
6059 int res1 = 0 ;
6060 PyObject *swig_obj[1] ;
6061
6062 if (!args) SWIG_fail;
6063 swig_obj[0] = args;
6064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6065 if (!SWIG_IsOK(res1)) {
6066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6067 }
6068 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6069 {
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 delete_wxGridCellAttr(arg1);
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 resultobj = SWIG_Py_Void();
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 PyObject *resultobj = 0;
6085 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6086 wxGridCellAttr *result = 0 ;
6087 void *argp1 = 0 ;
6088 int res1 = 0 ;
6089 PyObject *swig_obj[1] ;
6090
6091 if (!args) SWIG_fail;
6092 swig_obj[0] = args;
6093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6094 if (!SWIG_IsOK(res1)) {
6095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6096 }
6097 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6098 {
6099 PyThreadState* __tstate = wxPyBeginAllowThreads();
6100 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6101 wxPyEndAllowThreads(__tstate);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 {
6105 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6106 }
6107 return resultobj;
6108 fail:
6109 return NULL;
6110 }
6111
6112
6113 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6114 PyObject *resultobj = 0;
6115 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6116 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6117 void *argp1 = 0 ;
6118 int res1 = 0 ;
6119 void *argp2 = 0 ;
6120 int res2 = 0 ;
6121 PyObject * obj0 = 0 ;
6122 PyObject * obj1 = 0 ;
6123 char * kwnames[] = {
6124 (char *) "self",(char *) "mergefrom", NULL
6125 };
6126
6127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6129 if (!SWIG_IsOK(res1)) {
6130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6131 }
6132 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6134 if (!SWIG_IsOK(res2)) {
6135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6136 }
6137 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 (arg1)->MergeWith(arg2);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_Py_Void();
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6152 PyObject *resultobj = 0;
6153 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6154 void *argp1 = 0 ;
6155 int res1 = 0 ;
6156 PyObject *swig_obj[1] ;
6157
6158 if (!args) SWIG_fail;
6159 swig_obj[0] = args;
6160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6161 if (!SWIG_IsOK(res1)) {
6162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6163 }
6164 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6165 {
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 (arg1)->IncRef();
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 resultobj = SWIG_Py_Void();
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 PyObject *resultobj = 0;
6180 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6181 void *argp1 = 0 ;
6182 int res1 = 0 ;
6183 PyObject *swig_obj[1] ;
6184
6185 if (!args) SWIG_fail;
6186 swig_obj[0] = args;
6187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6188 if (!SWIG_IsOK(res1)) {
6189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6190 }
6191 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6192 {
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 (arg1)->DecRef();
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 resultobj = SWIG_Py_Void();
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj = 0;
6207 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6208 wxColour *arg2 = 0 ;
6209 void *argp1 = 0 ;
6210 int res1 = 0 ;
6211 wxColour temp2 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 char * kwnames[] = {
6215 (char *) "self",(char *) "colText", NULL
6216 };
6217
6218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6220 if (!SWIG_IsOK(res1)) {
6221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6222 }
6223 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6224 {
6225 arg2 = &temp2;
6226 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6227 }
6228 {
6229 PyThreadState* __tstate = wxPyBeginAllowThreads();
6230 (arg1)->SetTextColour((wxColour const &)*arg2);
6231 wxPyEndAllowThreads(__tstate);
6232 if (PyErr_Occurred()) SWIG_fail;
6233 }
6234 resultobj = SWIG_Py_Void();
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6242 PyObject *resultobj = 0;
6243 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6244 wxColour *arg2 = 0 ;
6245 void *argp1 = 0 ;
6246 int res1 = 0 ;
6247 wxColour temp2 ;
6248 PyObject * obj0 = 0 ;
6249 PyObject * obj1 = 0 ;
6250 char * kwnames[] = {
6251 (char *) "self",(char *) "colBack", NULL
6252 };
6253
6254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",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_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6258 }
6259 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6260 {
6261 arg2 = &temp2;
6262 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6263 }
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj = 0;
6279 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6280 wxFont *arg2 = 0 ;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 void *argp2 = 0 ;
6284 int res2 = 0 ;
6285 PyObject * obj0 = 0 ;
6286 PyObject * obj1 = 0 ;
6287 char * kwnames[] = {
6288 (char *) "self",(char *) "font", NULL
6289 };
6290
6291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6293 if (!SWIG_IsOK(res1)) {
6294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6295 }
6296 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6298 if (!SWIG_IsOK(res2)) {
6299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6300 }
6301 if (!argp2) {
6302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6303 }
6304 arg2 = reinterpret_cast< wxFont * >(argp2);
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 (arg1)->SetFont((wxFont const &)*arg2);
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_Py_Void();
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6321 int arg2 ;
6322 int arg3 ;
6323 void *argp1 = 0 ;
6324 int res1 = 0 ;
6325 int val2 ;
6326 int ecode2 = 0 ;
6327 int val3 ;
6328 int ecode3 = 0 ;
6329 PyObject * obj0 = 0 ;
6330 PyObject * obj1 = 0 ;
6331 PyObject * obj2 = 0 ;
6332 char * kwnames[] = {
6333 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6334 };
6335
6336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6338 if (!SWIG_IsOK(res1)) {
6339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6340 }
6341 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6342 ecode2 = SWIG_AsVal_int(obj1, &val2);
6343 if (!SWIG_IsOK(ecode2)) {
6344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6345 }
6346 arg2 = static_cast< int >(val2);
6347 ecode3 = SWIG_AsVal_int(obj2, &val3);
6348 if (!SWIG_IsOK(ecode3)) {
6349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6350 }
6351 arg3 = static_cast< int >(val3);
6352 {
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 (arg1)->SetAlignment(arg2,arg3);
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 resultobj = SWIG_Py_Void();
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj = 0;
6367 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6368 int arg2 ;
6369 int arg3 ;
6370 void *argp1 = 0 ;
6371 int res1 = 0 ;
6372 int val2 ;
6373 int ecode2 = 0 ;
6374 int val3 ;
6375 int ecode3 = 0 ;
6376 PyObject * obj0 = 0 ;
6377 PyObject * obj1 = 0 ;
6378 PyObject * obj2 = 0 ;
6379 char * kwnames[] = {
6380 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6381 };
6382
6383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6385 if (!SWIG_IsOK(res1)) {
6386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6387 }
6388 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6389 ecode2 = SWIG_AsVal_int(obj1, &val2);
6390 if (!SWIG_IsOK(ecode2)) {
6391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6392 }
6393 arg2 = static_cast< int >(val2);
6394 ecode3 = SWIG_AsVal_int(obj2, &val3);
6395 if (!SWIG_IsOK(ecode3)) {
6396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6397 }
6398 arg3 = static_cast< int >(val3);
6399 {
6400 PyThreadState* __tstate = wxPyBeginAllowThreads();
6401 (arg1)->SetSize(arg2,arg3);
6402 wxPyEndAllowThreads(__tstate);
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 resultobj = SWIG_Py_Void();
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6413 PyObject *resultobj = 0;
6414 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6415 bool arg2 = (bool) true ;
6416 void *argp1 = 0 ;
6417 int res1 = 0 ;
6418 bool val2 ;
6419 int ecode2 = 0 ;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 char * kwnames[] = {
6423 (char *) "self",(char *) "allow", NULL
6424 };
6425
6426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6428 if (!SWIG_IsOK(res1)) {
6429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6430 }
6431 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6432 if (obj1) {
6433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6434 if (!SWIG_IsOK(ecode2)) {
6435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6436 }
6437 arg2 = static_cast< bool >(val2);
6438 }
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 (arg1)->SetOverflow(arg2);
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = SWIG_Py_Void();
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj = 0;
6454 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6455 bool arg2 = (bool) true ;
6456 void *argp1 = 0 ;
6457 int res1 = 0 ;
6458 bool val2 ;
6459 int ecode2 = 0 ;
6460 PyObject * obj0 = 0 ;
6461 PyObject * obj1 = 0 ;
6462 char * kwnames[] = {
6463 (char *) "self",(char *) "isReadOnly", NULL
6464 };
6465
6466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6470 }
6471 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6472 if (obj1) {
6473 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6474 if (!SWIG_IsOK(ecode2)) {
6475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6476 }
6477 arg2 = static_cast< bool >(val2);
6478 }
6479 {
6480 PyThreadState* __tstate = wxPyBeginAllowThreads();
6481 (arg1)->SetReadOnly(arg2);
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_Py_Void();
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj = 0;
6494 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6495 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6496 void *argp1 = 0 ;
6497 int res1 = 0 ;
6498 void *argp2 = 0 ;
6499 int res2 = 0 ;
6500 PyObject * obj0 = 0 ;
6501 PyObject * obj1 = 0 ;
6502 char * kwnames[] = {
6503 (char *) "self",(char *) "renderer", NULL
6504 };
6505
6506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6508 if (!SWIG_IsOK(res1)) {
6509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6510 }
6511 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6513 if (!SWIG_IsOK(res2)) {
6514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6515 }
6516 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 (arg1)->SetRenderer(arg2);
6520 wxPyEndAllowThreads(__tstate);
6521 if (PyErr_Occurred()) SWIG_fail;
6522 }
6523 resultobj = SWIG_Py_Void();
6524 return resultobj;
6525 fail:
6526 return NULL;
6527 }
6528
6529
6530 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6531 PyObject *resultobj = 0;
6532 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6533 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6534 void *argp1 = 0 ;
6535 int res1 = 0 ;
6536 void *argp2 = 0 ;
6537 int res2 = 0 ;
6538 PyObject * obj0 = 0 ;
6539 PyObject * obj1 = 0 ;
6540 char * kwnames[] = {
6541 (char *) "self",(char *) "editor", NULL
6542 };
6543
6544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6546 if (!SWIG_IsOK(res1)) {
6547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6548 }
6549 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6550 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6551 if (!SWIG_IsOK(res2)) {
6552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6553 }
6554 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6555 {
6556 PyThreadState* __tstate = wxPyBeginAllowThreads();
6557 (arg1)->SetEditor(arg2);
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 resultobj = SWIG_Py_Void();
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj = 0;
6570 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6571 wxGridCellAttr::wxAttrKind arg2 ;
6572 void *argp1 = 0 ;
6573 int res1 = 0 ;
6574 int val2 ;
6575 int ecode2 = 0 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "kind", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6586 }
6587 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6588 ecode2 = SWIG_AsVal_int(obj1, &val2);
6589 if (!SWIG_IsOK(ecode2)) {
6590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6591 }
6592 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetKind(arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6609 bool result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 {
6628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6629 }
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6639 bool result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 {
6658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6659 }
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6667 PyObject *resultobj = 0;
6668 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6669 bool result;
6670 void *argp1 = 0 ;
6671 int res1 = 0 ;
6672 PyObject *swig_obj[1] ;
6673
6674 if (!args) SWIG_fail;
6675 swig_obj[0] = args;
6676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6679 }
6680 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6681 {
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 {
6688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6689 }
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6699 bool result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 {
6718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6719 }
6720 return resultobj;
6721 fail:
6722 return NULL;
6723 }
6724
6725
6726 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6727 PyObject *resultobj = 0;
6728 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6729 bool result;
6730 void *argp1 = 0 ;
6731 int res1 = 0 ;
6732 PyObject *swig_obj[1] ;
6733
6734 if (!args) SWIG_fail;
6735 swig_obj[0] = args;
6736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6739 }
6740 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6741 {
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 {
6748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6749 }
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 {
6778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6779 }
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6787 PyObject *resultobj = 0;
6788 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6789 bool result;
6790 void *argp1 = 0 ;
6791 int res1 = 0 ;
6792 PyObject *swig_obj[1] ;
6793
6794 if (!args) SWIG_fail;
6795 swig_obj[0] = args;
6796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6797 if (!SWIG_IsOK(res1)) {
6798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6799 }
6800 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 {
6808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6809 }
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817 PyObject *resultobj = 0;
6818 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6819 bool result;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject *swig_obj[1] ;
6823
6824 if (!args) SWIG_fail;
6825 swig_obj[0] = args;
6826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6827 if (!SWIG_IsOK(res1)) {
6828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6829 }
6830 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6839 }
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6847 PyObject *resultobj = 0;
6848 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6849 wxColour result;
6850 void *argp1 = 0 ;
6851 int res1 = 0 ;
6852 PyObject *swig_obj[1] ;
6853
6854 if (!args) SWIG_fail;
6855 swig_obj[0] = args;
6856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6857 if (!SWIG_IsOK(res1)) {
6858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6859 }
6860 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6875 PyObject *resultobj = 0;
6876 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6877 wxColour result;
6878 void *argp1 = 0 ;
6879 int res1 = 0 ;
6880 PyObject *swig_obj[1] ;
6881
6882 if (!args) SWIG_fail;
6883 swig_obj[0] = args;
6884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6887 }
6888 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6903 PyObject *resultobj = 0;
6904 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6905 wxFont result;
6906 void *argp1 = 0 ;
6907 int res1 = 0 ;
6908 PyObject *swig_obj[1] ;
6909
6910 if (!args) SWIG_fail;
6911 swig_obj[0] = args;
6912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6913 if (!SWIG_IsOK(res1)) {
6914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6915 }
6916 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6917 {
6918 PyThreadState* __tstate = wxPyBeginAllowThreads();
6919 result = ((wxGridCellAttr const *)arg1)->GetFont();
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6931 PyObject *resultobj = 0;
6932 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6933 int *arg2 = (int *) 0 ;
6934 int *arg3 = (int *) 0 ;
6935 void *argp1 = 0 ;
6936 int res1 = 0 ;
6937 int temp2 ;
6938 int res2 = SWIG_TMPOBJ ;
6939 int temp3 ;
6940 int res3 = SWIG_TMPOBJ ;
6941 PyObject *swig_obj[1] ;
6942
6943 arg2 = &temp2;
6944 arg3 = &temp3;
6945 if (!args) SWIG_fail;
6946 swig_obj[0] = args;
6947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6948 if (!SWIG_IsOK(res1)) {
6949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6950 }
6951 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6952 {
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 if (SWIG_IsTmpObj(res2)) {
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6961 } else {
6962 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6964 }
6965 if (SWIG_IsTmpObj(res3)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6970 }
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6978 PyObject *resultobj = 0;
6979 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6980 int *arg2 = (int *) 0 ;
6981 int *arg3 = (int *) 0 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int temp2 ;
6985 int res2 = SWIG_TMPOBJ ;
6986 int temp3 ;
6987 int res3 = SWIG_TMPOBJ ;
6988 PyObject *swig_obj[1] ;
6989
6990 arg2 = &temp2;
6991 arg3 = &temp3;
6992 if (!args) SWIG_fail;
6993 swig_obj[0] = args;
6994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6997 }
6998 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6999 {
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_Py_Void();
7006 if (SWIG_IsTmpObj(res2)) {
7007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7008 } else {
7009 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7011 }
7012 if (SWIG_IsTmpObj(res3)) {
7013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7014 } else {
7015 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7017 }
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7027 bool result;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject *swig_obj[1] ;
7031
7032 if (!args) SWIG_fail;
7033 swig_obj[0] = args;
7034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 {
7046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7047 }
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7057 wxGrid *arg2 = (wxGrid *) 0 ;
7058 int arg3 ;
7059 int arg4 ;
7060 wxGridCellRenderer *result = 0 ;
7061 void *argp1 = 0 ;
7062 int res1 = 0 ;
7063 void *argp2 = 0 ;
7064 int res2 = 0 ;
7065 int val3 ;
7066 int ecode3 = 0 ;
7067 int val4 ;
7068 int ecode4 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 PyObject * obj2 = 0 ;
7072 PyObject * obj3 = 0 ;
7073 char * kwnames[] = {
7074 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7075 };
7076
7077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7079 if (!SWIG_IsOK(res1)) {
7080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7081 }
7082 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7084 if (!SWIG_IsOK(res2)) {
7085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7086 }
7087 arg2 = reinterpret_cast< wxGrid * >(argp2);
7088 ecode3 = SWIG_AsVal_int(obj2, &val3);
7089 if (!SWIG_IsOK(ecode3)) {
7090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7091 }
7092 arg3 = static_cast< int >(val3);
7093 ecode4 = SWIG_AsVal_int(obj3, &val4);
7094 if (!SWIG_IsOK(ecode4)) {
7095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7096 }
7097 arg4 = static_cast< int >(val4);
7098 {
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 {
7105 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7106 }
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = 0;
7115 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7116 wxGrid *arg2 = (wxGrid *) 0 ;
7117 int arg3 ;
7118 int arg4 ;
7119 wxGridCellEditor *result = 0 ;
7120 void *argp1 = 0 ;
7121 int res1 = 0 ;
7122 void *argp2 = 0 ;
7123 int res2 = 0 ;
7124 int val3 ;
7125 int ecode3 = 0 ;
7126 int val4 ;
7127 int ecode4 = 0 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 PyObject * obj2 = 0 ;
7131 PyObject * obj3 = 0 ;
7132 char * kwnames[] = {
7133 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7134 };
7135
7136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7138 if (!SWIG_IsOK(res1)) {
7139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7140 }
7141 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7143 if (!SWIG_IsOK(res2)) {
7144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7145 }
7146 arg2 = reinterpret_cast< wxGrid * >(argp2);
7147 ecode3 = SWIG_AsVal_int(obj2, &val3);
7148 if (!SWIG_IsOK(ecode3)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7150 }
7151 arg3 = static_cast< int >(val3);
7152 ecode4 = SWIG_AsVal_int(obj3, &val4);
7153 if (!SWIG_IsOK(ecode4)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7155 }
7156 arg4 = static_cast< int >(val4);
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 {
7164 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7165 }
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7173 PyObject *resultobj = 0;
7174 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7175 bool result;
7176 void *argp1 = 0 ;
7177 int res1 = 0 ;
7178 PyObject *swig_obj[1] ;
7179
7180 if (!args) SWIG_fail;
7181 swig_obj[0] = args;
7182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7185 }
7186 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 {
7194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7195 }
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7203 PyObject *resultobj = 0;
7204 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7205 wxGridCellAttr::wxAttrKind result;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 PyObject *swig_obj[1] ;
7209
7210 if (!args) SWIG_fail;
7211 swig_obj[0] = args;
7212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7213 if (!SWIG_IsOK(res1)) {
7214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7215 }
7216 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7217 {
7218 PyThreadState* __tstate = wxPyBeginAllowThreads();
7219 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7220 wxPyEndAllowThreads(__tstate);
7221 if (PyErr_Occurred()) SWIG_fail;
7222 }
7223 resultobj = SWIG_From_int(static_cast< int >(result));
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj = 0;
7232 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7233 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7234 void *argp1 = 0 ;
7235 int res1 = 0 ;
7236 void *argp2 = 0 ;
7237 int res2 = 0 ;
7238 PyObject * obj0 = 0 ;
7239 PyObject * obj1 = 0 ;
7240 char * kwnames[] = {
7241 (char *) "self",(char *) "defAttr", NULL
7242 };
7243
7244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7246 if (!SWIG_IsOK(res1)) {
7247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7248 }
7249 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7251 if (!SWIG_IsOK(res2)) {
7252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7253 }
7254 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 (arg1)->SetDefAttr(arg2);
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_Py_Void();
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7269 PyObject *obj;
7270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7271 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7272 return SWIG_Py_Void();
7273 }
7274
7275 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7276 return SWIG_Python_InitShadowInstance(args);
7277 }
7278
7279 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7280 PyObject *resultobj = 0;
7281 wxGridCellAttrProvider *result = 0 ;
7282
7283 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 {
7291 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7292 }
7293 return resultobj;
7294 fail:
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7302 PyObject *arg2 = (PyObject *) 0 ;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 PyObject * obj1 = 0 ;
7307 char * kwnames[] = {
7308 (char *) "self",(char *) "_self", NULL
7309 };
7310
7311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7313 if (!SWIG_IsOK(res1)) {
7314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7315 }
7316 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7317 arg2 = obj1;
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_Py_Void();
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj = 0;
7333 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7334 int arg2 ;
7335 int arg3 ;
7336 wxGridCellAttr::wxAttrKind arg4 ;
7337 wxGridCellAttr *result = 0 ;
7338 void *argp1 = 0 ;
7339 int res1 = 0 ;
7340 int val2 ;
7341 int ecode2 = 0 ;
7342 int val3 ;
7343 int ecode3 = 0 ;
7344 int val4 ;
7345 int ecode4 = 0 ;
7346 PyObject * obj0 = 0 ;
7347 PyObject * obj1 = 0 ;
7348 PyObject * obj2 = 0 ;
7349 PyObject * obj3 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7358 }
7359 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7360 ecode2 = SWIG_AsVal_int(obj1, &val2);
7361 if (!SWIG_IsOK(ecode2)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7363 }
7364 arg2 = static_cast< int >(val2);
7365 ecode3 = SWIG_AsVal_int(obj2, &val3);
7366 if (!SWIG_IsOK(ecode3)) {
7367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7368 }
7369 arg3 = static_cast< int >(val3);
7370 ecode4 = SWIG_AsVal_int(obj3, &val4);
7371 if (!SWIG_IsOK(ecode4)) {
7372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7373 }
7374 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 {
7382 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7383 }
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj = 0;
7392 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7393 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7394 int arg3 ;
7395 int arg4 ;
7396 void *argp1 = 0 ;
7397 int res1 = 0 ;
7398 void *argp2 = 0 ;
7399 int res2 = 0 ;
7400 int val3 ;
7401 int ecode3 = 0 ;
7402 int val4 ;
7403 int ecode4 = 0 ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 PyObject * obj2 = 0 ;
7407 PyObject * obj3 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7416 }
7417 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7419 if (!SWIG_IsOK(res2)) {
7420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7421 }
7422 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7423 ecode3 = SWIG_AsVal_int(obj2, &val3);
7424 if (!SWIG_IsOK(ecode3)) {
7425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7426 }
7427 arg3 = static_cast< int >(val3);
7428 ecode4 = SWIG_AsVal_int(obj3, &val4);
7429 if (!SWIG_IsOK(ecode4)) {
7430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7431 }
7432 arg4 = static_cast< int >(val4);
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 (arg1)->SetAttr(arg2,arg3,arg4);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 resultobj = SWIG_Py_Void();
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj = 0;
7448 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7449 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7450 int arg3 ;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 void *argp2 = 0 ;
7454 int res2 = 0 ;
7455 int val3 ;
7456 int ecode3 = 0 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 PyObject * obj2 = 0 ;
7460 char * kwnames[] = {
7461 (char *) "self",(char *) "attr",(char *) "row", NULL
7462 };
7463
7464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7466 if (!SWIG_IsOK(res1)) {
7467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7468 }
7469 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7471 if (!SWIG_IsOK(res2)) {
7472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7473 }
7474 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7475 ecode3 = SWIG_AsVal_int(obj2, &val3);
7476 if (!SWIG_IsOK(ecode3)) {
7477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7478 }
7479 arg3 = static_cast< int >(val3);
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 (arg1)->SetRowAttr(arg2,arg3);
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = SWIG_Py_Void();
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7496 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7497 int arg3 ;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 void *argp2 = 0 ;
7501 int res2 = 0 ;
7502 int val3 ;
7503 int ecode3 = 0 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 PyObject * obj2 = 0 ;
7507 char * kwnames[] = {
7508 (char *) "self",(char *) "attr",(char *) "col", NULL
7509 };
7510
7511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7515 }
7516 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7518 if (!SWIG_IsOK(res2)) {
7519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7520 }
7521 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7522 ecode3 = SWIG_AsVal_int(obj2, &val3);
7523 if (!SWIG_IsOK(ecode3)) {
7524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7525 }
7526 arg3 = static_cast< int >(val3);
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 (arg1)->SetColAttr(arg2,arg3);
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 resultobj = SWIG_Py_Void();
7534 return resultobj;
7535 fail:
7536 return NULL;
7537 }
7538
7539
7540 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7541 PyObject *resultobj = 0;
7542 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7543 size_t arg2 ;
7544 int arg3 ;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 size_t val2 ;
7548 int ecode2 = 0 ;
7549 int val3 ;
7550 int ecode3 = 0 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 PyObject * obj2 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7562 }
7563 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7564 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7565 if (!SWIG_IsOK(ecode2)) {
7566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7567 }
7568 arg2 = static_cast< size_t >(val2);
7569 ecode3 = SWIG_AsVal_int(obj2, &val3);
7570 if (!SWIG_IsOK(ecode3)) {
7571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7572 }
7573 arg3 = static_cast< int >(val3);
7574 {
7575 PyThreadState* __tstate = wxPyBeginAllowThreads();
7576 (arg1)->UpdateAttrRows(arg2,arg3);
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 resultobj = SWIG_Py_Void();
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = 0;
7589 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7590 size_t arg2 ;
7591 int arg3 ;
7592 void *argp1 = 0 ;
7593 int res1 = 0 ;
7594 size_t val2 ;
7595 int ecode2 = 0 ;
7596 int val3 ;
7597 int ecode3 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 PyObject * obj2 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7609 }
7610 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7611 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7612 if (!SWIG_IsOK(ecode2)) {
7613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7614 }
7615 arg2 = static_cast< size_t >(val2);
7616 ecode3 = SWIG_AsVal_int(obj2, &val3);
7617 if (!SWIG_IsOK(ecode3)) {
7618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7619 }
7620 arg3 = static_cast< int >(val3);
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 (arg1)->UpdateAttrCols(arg2,arg3);
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 resultobj = SWIG_Py_Void();
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7635 PyObject *obj;
7636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7637 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7638 return SWIG_Py_Void();
7639 }
7640
7641 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7642 return SWIG_Python_InitShadowInstance(args);
7643 }
7644
7645 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 PyObject *resultobj = 0;
7647 wxPyGridCellAttrProvider *result = 0 ;
7648
7649 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj = 0;
7665 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7666 PyObject *arg2 = (PyObject *) 0 ;
7667 PyObject *arg3 = (PyObject *) 0 ;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 PyObject * obj2 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "self",(char *) "_class", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7681 }
7682 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7683 arg2 = obj1;
7684 arg3 = obj2;
7685 {
7686 PyThreadState* __tstate = wxPyBeginAllowThreads();
7687 (arg1)->_setCallbackInfo(arg2,arg3);
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_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7699 PyObject *resultobj = 0;
7700 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7701 int arg2 ;
7702 int arg3 ;
7703 wxGridCellAttr::wxAttrKind arg4 ;
7704 wxGridCellAttr *result = 0 ;
7705 void *argp1 = 0 ;
7706 int res1 = 0 ;
7707 int val2 ;
7708 int ecode2 = 0 ;
7709 int val3 ;
7710 int ecode3 = 0 ;
7711 int val4 ;
7712 int ecode4 = 0 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 PyObject * obj2 = 0 ;
7716 PyObject * obj3 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7725 }
7726 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7727 ecode2 = SWIG_AsVal_int(obj1, &val2);
7728 if (!SWIG_IsOK(ecode2)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7730 }
7731 arg2 = static_cast< int >(val2);
7732 ecode3 = SWIG_AsVal_int(obj2, &val3);
7733 if (!SWIG_IsOK(ecode3)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7735 }
7736 arg3 = static_cast< int >(val3);
7737 ecode4 = SWIG_AsVal_int(obj3, &val4);
7738 if (!SWIG_IsOK(ecode4)) {
7739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7740 }
7741 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7742 {
7743 PyThreadState* __tstate = wxPyBeginAllowThreads();
7744 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7745 wxPyEndAllowThreads(__tstate);
7746 if (PyErr_Occurred()) SWIG_fail;
7747 }
7748 {
7749 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7750 }
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7758 PyObject *resultobj = 0;
7759 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7760 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7761 int arg3 ;
7762 int arg4 ;
7763 void *argp1 = 0 ;
7764 int res1 = 0 ;
7765 void *argp2 = 0 ;
7766 int res2 = 0 ;
7767 int val3 ;
7768 int ecode3 = 0 ;
7769 int val4 ;
7770 int ecode4 = 0 ;
7771 PyObject * obj0 = 0 ;
7772 PyObject * obj1 = 0 ;
7773 PyObject * obj2 = 0 ;
7774 PyObject * obj3 = 0 ;
7775 char * kwnames[] = {
7776 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7777 };
7778
7779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7781 if (!SWIG_IsOK(res1)) {
7782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7783 }
7784 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7786 if (!SWIG_IsOK(res2)) {
7787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7788 }
7789 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7790 ecode3 = SWIG_AsVal_int(obj2, &val3);
7791 if (!SWIG_IsOK(ecode3)) {
7792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7793 }
7794 arg3 = static_cast< int >(val3);
7795 ecode4 = SWIG_AsVal_int(obj3, &val4);
7796 if (!SWIG_IsOK(ecode4)) {
7797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7798 }
7799 arg4 = static_cast< int >(val4);
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 (arg1)->SetAttr(arg2,arg3,arg4);
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 resultobj = SWIG_Py_Void();
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj = 0;
7815 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7816 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7817 int arg3 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 void *argp2 = 0 ;
7821 int res2 = 0 ;
7822 int val3 ;
7823 int ecode3 = 0 ;
7824 PyObject * obj0 = 0 ;
7825 PyObject * obj1 = 0 ;
7826 PyObject * obj2 = 0 ;
7827 char * kwnames[] = {
7828 (char *) "self",(char *) "attr",(char *) "row", NULL
7829 };
7830
7831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7833 if (!SWIG_IsOK(res1)) {
7834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7835 }
7836 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7838 if (!SWIG_IsOK(res2)) {
7839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7840 }
7841 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7842 ecode3 = SWIG_AsVal_int(obj2, &val3);
7843 if (!SWIG_IsOK(ecode3)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7845 }
7846 arg3 = static_cast< int >(val3);
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 (arg1)->SetRowAttr(arg2,arg3);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7863 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7864 int arg3 ;
7865 void *argp1 = 0 ;
7866 int res1 = 0 ;
7867 void *argp2 = 0 ;
7868 int res2 = 0 ;
7869 int val3 ;
7870 int ecode3 = 0 ;
7871 PyObject * obj0 = 0 ;
7872 PyObject * obj1 = 0 ;
7873 PyObject * obj2 = 0 ;
7874 char * kwnames[] = {
7875 (char *) "self",(char *) "attr",(char *) "col", NULL
7876 };
7877
7878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7882 }
7883 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7885 if (!SWIG_IsOK(res2)) {
7886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7887 }
7888 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7889 ecode3 = SWIG_AsVal_int(obj2, &val3);
7890 if (!SWIG_IsOK(ecode3)) {
7891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7892 }
7893 arg3 = static_cast< int >(val3);
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 (arg1)->SetColAttr(arg2,arg3);
7897 wxPyEndAllowThreads(__tstate);
7898 if (PyErr_Occurred()) SWIG_fail;
7899 }
7900 resultobj = SWIG_Py_Void();
7901 return resultobj;
7902 fail:
7903 return NULL;
7904 }
7905
7906
7907 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7908 PyObject *obj;
7909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7911 return SWIG_Py_Void();
7912 }
7913
7914 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7915 return SWIG_Python_InitShadowInstance(args);
7916 }
7917
7918 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 PyObject *resultobj = 0;
7920 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 PyObject *swig_obj[1] ;
7924
7925 if (!args) SWIG_fail;
7926 swig_obj[0] = args;
7927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7930 }
7931 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7932 {
7933 PyThreadState* __tstate = wxPyBeginAllowThreads();
7934 delete arg1;
7935
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 resultobj = SWIG_Py_Void();
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7947 PyObject *resultobj = 0;
7948 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7949 PyObject *arg2 = (PyObject *) 0 ;
7950 void *argp1 = 0 ;
7951 int res1 = 0 ;
7952 PyObject * obj0 = 0 ;
7953 PyObject * obj1 = 0 ;
7954 char * kwnames[] = {
7955 (char *) "self",(char *) "_self", NULL
7956 };
7957
7958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7960 if (!SWIG_IsOK(res1)) {
7961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7962 }
7963 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7964 arg2 = obj1;
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 wxGridTableBase__setOORInfo(arg1,arg2);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7981 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 void *argp2 = 0 ;
7985 int res2 = 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "self",(char *) "attrProvider", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7996 }
7997 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7999 if (!SWIG_IsOK(res2)) {
8000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8001 }
8002 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetAttrProvider(arg2);
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8019 wxGridCellAttrProvider *result = 0 ;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8029 }
8030 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8031 {
8032 PyThreadState* __tstate = wxPyBeginAllowThreads();
8033 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 {
8038 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8039 }
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj = 0;
8048 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8049 wxGrid *arg2 = (wxGrid *) 0 ;
8050 void *argp1 = 0 ;
8051 int res1 = 0 ;
8052 void *argp2 = 0 ;
8053 int res2 = 0 ;
8054 PyObject * obj0 = 0 ;
8055 PyObject * obj1 = 0 ;
8056 char * kwnames[] = {
8057 (char *) "self",(char *) "grid", NULL
8058 };
8059
8060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8062 if (!SWIG_IsOK(res1)) {
8063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8064 }
8065 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8067 if (!SWIG_IsOK(res2)) {
8068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8069 }
8070 arg2 = reinterpret_cast< wxGrid * >(argp2);
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 (arg1)->SetView(arg2);
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 resultobj = SWIG_Py_Void();
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8085 PyObject *resultobj = 0;
8086 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8087 wxGrid *result = 0 ;
8088 void *argp1 = 0 ;
8089 int res1 = 0 ;
8090 PyObject *swig_obj[1] ;
8091
8092 if (!args) SWIG_fail;
8093 swig_obj[0] = args;
8094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8095 if (!SWIG_IsOK(res1)) {
8096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8097 }
8098 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8099 {
8100 PyThreadState* __tstate = wxPyBeginAllowThreads();
8101 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 resultobj = wxPyMake_wxObject(result, (bool)0);
8107 }
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8117 int result;
8118 void *argp1 = 0 ;
8119 int res1 = 0 ;
8120 PyObject *swig_obj[1] ;
8121
8122 if (!args) SWIG_fail;
8123 swig_obj[0] = args;
8124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8125 if (!SWIG_IsOK(res1)) {
8126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8127 }
8128 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8129 {
8130 PyThreadState* __tstate = wxPyBeginAllowThreads();
8131 result = (int)(arg1)->GetNumberRows();
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 resultobj = SWIG_From_int(static_cast< int >(result));
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8143 PyObject *resultobj = 0;
8144 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8145 int result;
8146 void *argp1 = 0 ;
8147 int res1 = 0 ;
8148 PyObject *swig_obj[1] ;
8149
8150 if (!args) SWIG_fail;
8151 swig_obj[0] = args;
8152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8153 if (!SWIG_IsOK(res1)) {
8154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8155 }
8156 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8157 {
8158 PyThreadState* __tstate = wxPyBeginAllowThreads();
8159 result = (int)(arg1)->GetNumberCols();
8160 wxPyEndAllowThreads(__tstate);
8161 if (PyErr_Occurred()) SWIG_fail;
8162 }
8163 resultobj = SWIG_From_int(static_cast< int >(result));
8164 return resultobj;
8165 fail:
8166 return NULL;
8167 }
8168
8169
8170 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8171 PyObject *resultobj = 0;
8172 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8173 int arg2 ;
8174 int arg3 ;
8175 bool result;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int val2 ;
8179 int ecode2 = 0 ;
8180 int val3 ;
8181 int ecode3 = 0 ;
8182 PyObject * obj0 = 0 ;
8183 PyObject * obj1 = 0 ;
8184 PyObject * obj2 = 0 ;
8185 char * kwnames[] = {
8186 (char *) "self",(char *) "row",(char *) "col", NULL
8187 };
8188
8189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8191 if (!SWIG_IsOK(res1)) {
8192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8193 }
8194 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8195 ecode2 = SWIG_AsVal_int(obj1, &val2);
8196 if (!SWIG_IsOK(ecode2)) {
8197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8198 }
8199 arg2 = static_cast< int >(val2);
8200 ecode3 = SWIG_AsVal_int(obj2, &val3);
8201 if (!SWIG_IsOK(ecode3)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8203 }
8204 arg3 = static_cast< int >(val3);
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8213 }
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj = 0;
8222 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8223 int arg2 ;
8224 int arg3 ;
8225 wxString result;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 int val2 ;
8229 int ecode2 = 0 ;
8230 int val3 ;
8231 int ecode3 = 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 PyObject * obj2 = 0 ;
8235 char * kwnames[] = {
8236 (char *) "self",(char *) "row",(char *) "col", NULL
8237 };
8238
8239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8241 if (!SWIG_IsOK(res1)) {
8242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8243 }
8244 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8245 ecode2 = SWIG_AsVal_int(obj1, &val2);
8246 if (!SWIG_IsOK(ecode2)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8248 }
8249 arg2 = static_cast< int >(val2);
8250 ecode3 = SWIG_AsVal_int(obj2, &val3);
8251 if (!SWIG_IsOK(ecode3)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8253 }
8254 arg3 = static_cast< int >(val3);
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (arg1)->GetValue(arg2,arg3);
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 {
8262 #if wxUSE_UNICODE
8263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8264 #else
8265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8266 #endif
8267 }
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8277 int arg2 ;
8278 int arg3 ;
8279 wxString *arg4 = 0 ;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 int val2 ;
8283 int ecode2 = 0 ;
8284 int val3 ;
8285 int ecode3 = 0 ;
8286 bool temp4 = false ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 PyObject * obj2 = 0 ;
8290 PyObject * obj3 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8297 if (!SWIG_IsOK(res1)) {
8298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8299 }
8300 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8301 ecode2 = SWIG_AsVal_int(obj1, &val2);
8302 if (!SWIG_IsOK(ecode2)) {
8303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8304 }
8305 arg2 = static_cast< int >(val2);
8306 ecode3 = SWIG_AsVal_int(obj2, &val3);
8307 if (!SWIG_IsOK(ecode3)) {
8308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8309 }
8310 arg3 = static_cast< int >(val3);
8311 {
8312 arg4 = wxString_in_helper(obj3);
8313 if (arg4 == NULL) SWIG_fail;
8314 temp4 = true;
8315 }
8316 {
8317 PyThreadState* __tstate = wxPyBeginAllowThreads();
8318 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 resultobj = SWIG_Py_Void();
8323 {
8324 if (temp4)
8325 delete arg4;
8326 }
8327 return resultobj;
8328 fail:
8329 {
8330 if (temp4)
8331 delete arg4;
8332 }
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = 0;
8339 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8340 int arg2 ;
8341 int arg3 ;
8342 wxString result;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 int val2 ;
8346 int ecode2 = 0 ;
8347 int val3 ;
8348 int ecode3 = 0 ;
8349 PyObject * obj0 = 0 ;
8350 PyObject * obj1 = 0 ;
8351 PyObject * obj2 = 0 ;
8352 char * kwnames[] = {
8353 (char *) "self",(char *) "row",(char *) "col", NULL
8354 };
8355
8356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8358 if (!SWIG_IsOK(res1)) {
8359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8360 }
8361 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8362 ecode2 = SWIG_AsVal_int(obj1, &val2);
8363 if (!SWIG_IsOK(ecode2)) {
8364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8365 }
8366 arg2 = static_cast< int >(val2);
8367 ecode3 = SWIG_AsVal_int(obj2, &val3);
8368 if (!SWIG_IsOK(ecode3)) {
8369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8370 }
8371 arg3 = static_cast< int >(val3);
8372 {
8373 PyThreadState* __tstate = wxPyBeginAllowThreads();
8374 result = (arg1)->GetTypeName(arg2,arg3);
8375 wxPyEndAllowThreads(__tstate);
8376 if (PyErr_Occurred()) SWIG_fail;
8377 }
8378 {
8379 #if wxUSE_UNICODE
8380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8381 #else
8382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8383 #endif
8384 }
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj = 0;
8393 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8394 int arg2 ;
8395 int arg3 ;
8396 wxString *arg4 = 0 ;
8397 bool result;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 int val2 ;
8401 int ecode2 = 0 ;
8402 int val3 ;
8403 int ecode3 = 0 ;
8404 bool temp4 = false ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 PyObject * obj2 = 0 ;
8408 PyObject * obj3 = 0 ;
8409 char * kwnames[] = {
8410 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8411 };
8412
8413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8417 }
8418 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8419 ecode2 = SWIG_AsVal_int(obj1, &val2);
8420 if (!SWIG_IsOK(ecode2)) {
8421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8422 }
8423 arg2 = static_cast< int >(val2);
8424 ecode3 = SWIG_AsVal_int(obj2, &val3);
8425 if (!SWIG_IsOK(ecode3)) {
8426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8427 }
8428 arg3 = static_cast< int >(val3);
8429 {
8430 arg4 = wxString_in_helper(obj3);
8431 if (arg4 == NULL) SWIG_fail;
8432 temp4 = true;
8433 }
8434 {
8435 PyThreadState* __tstate = wxPyBeginAllowThreads();
8436 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 {
8441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8442 }
8443 {
8444 if (temp4)
8445 delete arg4;
8446 }
8447 return resultobj;
8448 fail:
8449 {
8450 if (temp4)
8451 delete arg4;
8452 }
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8460 int arg2 ;
8461 int arg3 ;
8462 wxString *arg4 = 0 ;
8463 bool result;
8464 void *argp1 = 0 ;
8465 int res1 = 0 ;
8466 int val2 ;
8467 int ecode2 = 0 ;
8468 int val3 ;
8469 int ecode3 = 0 ;
8470 bool temp4 = false ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 PyObject * obj2 = 0 ;
8474 PyObject * obj3 = 0 ;
8475 char * kwnames[] = {
8476 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8477 };
8478
8479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8481 if (!SWIG_IsOK(res1)) {
8482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8483 }
8484 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8485 ecode2 = SWIG_AsVal_int(obj1, &val2);
8486 if (!SWIG_IsOK(ecode2)) {
8487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8488 }
8489 arg2 = static_cast< int >(val2);
8490 ecode3 = SWIG_AsVal_int(obj2, &val3);
8491 if (!SWIG_IsOK(ecode3)) {
8492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8493 }
8494 arg3 = static_cast< int >(val3);
8495 {
8496 arg4 = wxString_in_helper(obj3);
8497 if (arg4 == NULL) SWIG_fail;
8498 temp4 = true;
8499 }
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 {
8507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8508 }
8509 {
8510 if (temp4)
8511 delete arg4;
8512 }
8513 return resultobj;
8514 fail:
8515 {
8516 if (temp4)
8517 delete arg4;
8518 }
8519 return NULL;
8520 }
8521
8522
8523 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8524 PyObject *resultobj = 0;
8525 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8526 int arg2 ;
8527 int arg3 ;
8528 long result;
8529 void *argp1 = 0 ;
8530 int res1 = 0 ;
8531 int val2 ;
8532 int ecode2 = 0 ;
8533 int val3 ;
8534 int ecode3 = 0 ;
8535 PyObject * obj0 = 0 ;
8536 PyObject * obj1 = 0 ;
8537 PyObject * obj2 = 0 ;
8538 char * kwnames[] = {
8539 (char *) "self",(char *) "row",(char *) "col", NULL
8540 };
8541
8542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8546 }
8547 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8548 ecode2 = SWIG_AsVal_int(obj1, &val2);
8549 if (!SWIG_IsOK(ecode2)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8551 }
8552 arg2 = static_cast< int >(val2);
8553 ecode3 = SWIG_AsVal_int(obj2, &val3);
8554 if (!SWIG_IsOK(ecode3)) {
8555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8556 }
8557 arg3 = static_cast< int >(val3);
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 resultobj = SWIG_From_long(static_cast< long >(result));
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj = 0;
8573 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8574 int arg2 ;
8575 int arg3 ;
8576 double result;
8577 void *argp1 = 0 ;
8578 int res1 = 0 ;
8579 int val2 ;
8580 int ecode2 = 0 ;
8581 int val3 ;
8582 int ecode3 = 0 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 PyObject * obj2 = 0 ;
8586 char * kwnames[] = {
8587 (char *) "self",(char *) "row",(char *) "col", NULL
8588 };
8589
8590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8592 if (!SWIG_IsOK(res1)) {
8593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8594 }
8595 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8596 ecode2 = SWIG_AsVal_int(obj1, &val2);
8597 if (!SWIG_IsOK(ecode2)) {
8598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8599 }
8600 arg2 = static_cast< int >(val2);
8601 ecode3 = SWIG_AsVal_int(obj2, &val3);
8602 if (!SWIG_IsOK(ecode3)) {
8603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8604 }
8605 arg3 = static_cast< int >(val3);
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 resultobj = SWIG_From_double(static_cast< double >(result));
8613 return resultobj;
8614 fail:
8615 return NULL;
8616 }
8617
8618
8619 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8620 PyObject *resultobj = 0;
8621 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8622 int arg2 ;
8623 int arg3 ;
8624 bool result;
8625 void *argp1 = 0 ;
8626 int res1 = 0 ;
8627 int val2 ;
8628 int ecode2 = 0 ;
8629 int val3 ;
8630 int ecode3 = 0 ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 PyObject * obj2 = 0 ;
8634 char * kwnames[] = {
8635 (char *) "self",(char *) "row",(char *) "col", NULL
8636 };
8637
8638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8640 if (!SWIG_IsOK(res1)) {
8641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8642 }
8643 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8644 ecode2 = SWIG_AsVal_int(obj1, &val2);
8645 if (!SWIG_IsOK(ecode2)) {
8646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8647 }
8648 arg2 = static_cast< int >(val2);
8649 ecode3 = SWIG_AsVal_int(obj2, &val3);
8650 if (!SWIG_IsOK(ecode3)) {
8651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8652 }
8653 arg3 = static_cast< int >(val3);
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8657 wxPyEndAllowThreads(__tstate);
8658 if (PyErr_Occurred()) SWIG_fail;
8659 }
8660 {
8661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8662 }
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj = 0;
8671 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8672 int arg2 ;
8673 int arg3 ;
8674 long arg4 ;
8675 void *argp1 = 0 ;
8676 int res1 = 0 ;
8677 int val2 ;
8678 int ecode2 = 0 ;
8679 int val3 ;
8680 int ecode3 = 0 ;
8681 long val4 ;
8682 int ecode4 = 0 ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 PyObject * obj2 = 0 ;
8686 PyObject * obj3 = 0 ;
8687 char * kwnames[] = {
8688 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8689 };
8690
8691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8693 if (!SWIG_IsOK(res1)) {
8694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8695 }
8696 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8697 ecode2 = SWIG_AsVal_int(obj1, &val2);
8698 if (!SWIG_IsOK(ecode2)) {
8699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8700 }
8701 arg2 = static_cast< int >(val2);
8702 ecode3 = SWIG_AsVal_int(obj2, &val3);
8703 if (!SWIG_IsOK(ecode3)) {
8704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8705 }
8706 arg3 = static_cast< int >(val3);
8707 ecode4 = SWIG_AsVal_long(obj3, &val4);
8708 if (!SWIG_IsOK(ecode4)) {
8709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8710 }
8711 arg4 = static_cast< long >(val4);
8712 {
8713 PyThreadState* __tstate = wxPyBeginAllowThreads();
8714 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 resultobj = SWIG_Py_Void();
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8726 PyObject *resultobj = 0;
8727 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8728 int arg2 ;
8729 int arg3 ;
8730 double arg4 ;
8731 void *argp1 = 0 ;
8732 int res1 = 0 ;
8733 int val2 ;
8734 int ecode2 = 0 ;
8735 int val3 ;
8736 int ecode3 = 0 ;
8737 double val4 ;
8738 int ecode4 = 0 ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 PyObject * obj2 = 0 ;
8742 PyObject * obj3 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8751 }
8752 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8753 ecode2 = SWIG_AsVal_int(obj1, &val2);
8754 if (!SWIG_IsOK(ecode2)) {
8755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8756 }
8757 arg2 = static_cast< int >(val2);
8758 ecode3 = SWIG_AsVal_int(obj2, &val3);
8759 if (!SWIG_IsOK(ecode3)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8761 }
8762 arg3 = static_cast< int >(val3);
8763 ecode4 = SWIG_AsVal_double(obj3, &val4);
8764 if (!SWIG_IsOK(ecode4)) {
8765 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8766 }
8767 arg4 = static_cast< double >(val4);
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 resultobj = SWIG_Py_Void();
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj = 0;
8783 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8784 int arg2 ;
8785 int arg3 ;
8786 bool arg4 ;
8787 void *argp1 = 0 ;
8788 int res1 = 0 ;
8789 int val2 ;
8790 int ecode2 = 0 ;
8791 int val3 ;
8792 int ecode3 = 0 ;
8793 bool val4 ;
8794 int ecode4 = 0 ;
8795 PyObject * obj0 = 0 ;
8796 PyObject * obj1 = 0 ;
8797 PyObject * obj2 = 0 ;
8798 PyObject * obj3 = 0 ;
8799 char * kwnames[] = {
8800 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8801 };
8802
8803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8805 if (!SWIG_IsOK(res1)) {
8806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8807 }
8808 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8809 ecode2 = SWIG_AsVal_int(obj1, &val2);
8810 if (!SWIG_IsOK(ecode2)) {
8811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8812 }
8813 arg2 = static_cast< int >(val2);
8814 ecode3 = SWIG_AsVal_int(obj2, &val3);
8815 if (!SWIG_IsOK(ecode3)) {
8816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8817 }
8818 arg3 = static_cast< int >(val3);
8819 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8820 if (!SWIG_IsOK(ecode4)) {
8821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8822 }
8823 arg4 = static_cast< bool >(val4);
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 PyObject *swig_obj[1] ;
8843
8844 if (!args) SWIG_fail;
8845 swig_obj[0] = args;
8846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8847 if (!SWIG_IsOK(res1)) {
8848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8849 }
8850 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 (arg1)->Clear();
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_Py_Void();
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8865 PyObject *resultobj = 0;
8866 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8867 size_t arg2 = (size_t) 0 ;
8868 size_t arg3 = (size_t) 1 ;
8869 bool result;
8870 void *argp1 = 0 ;
8871 int res1 = 0 ;
8872 size_t val2 ;
8873 int ecode2 = 0 ;
8874 size_t val3 ;
8875 int ecode3 = 0 ;
8876 PyObject * obj0 = 0 ;
8877 PyObject * obj1 = 0 ;
8878 PyObject * obj2 = 0 ;
8879 char * kwnames[] = {
8880 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8881 };
8882
8883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8887 }
8888 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8889 if (obj1) {
8890 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8891 if (!SWIG_IsOK(ecode2)) {
8892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8893 }
8894 arg2 = static_cast< size_t >(val2);
8895 }
8896 if (obj2) {
8897 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8898 if (!SWIG_IsOK(ecode3)) {
8899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8900 }
8901 arg3 = static_cast< size_t >(val3);
8902 }
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 result = (bool)(arg1)->InsertRows(arg2,arg3);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 {
8910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8911 }
8912 return resultobj;
8913 fail:
8914 return NULL;
8915 }
8916
8917
8918 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj = 0;
8920 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8921 size_t arg2 = (size_t) 1 ;
8922 bool result;
8923 void *argp1 = 0 ;
8924 int res1 = 0 ;
8925 size_t val2 ;
8926 int ecode2 = 0 ;
8927 PyObject * obj0 = 0 ;
8928 PyObject * obj1 = 0 ;
8929 char * kwnames[] = {
8930 (char *) "self",(char *) "numRows", NULL
8931 };
8932
8933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8935 if (!SWIG_IsOK(res1)) {
8936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8937 }
8938 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8939 if (obj1) {
8940 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8941 if (!SWIG_IsOK(ecode2)) {
8942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8943 }
8944 arg2 = static_cast< size_t >(val2);
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 result = (bool)(arg1)->AppendRows(arg2);
8949 wxPyEndAllowThreads(__tstate);
8950 if (PyErr_Occurred()) SWIG_fail;
8951 }
8952 {
8953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8954 }
8955 return resultobj;
8956 fail:
8957 return NULL;
8958 }
8959
8960
8961 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8962 PyObject *resultobj = 0;
8963 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8964 size_t arg2 = (size_t) 0 ;
8965 size_t arg3 = (size_t) 1 ;
8966 bool result;
8967 void *argp1 = 0 ;
8968 int res1 = 0 ;
8969 size_t val2 ;
8970 int ecode2 = 0 ;
8971 size_t val3 ;
8972 int ecode3 = 0 ;
8973 PyObject * obj0 = 0 ;
8974 PyObject * obj1 = 0 ;
8975 PyObject * obj2 = 0 ;
8976 char * kwnames[] = {
8977 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8978 };
8979
8980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8982 if (!SWIG_IsOK(res1)) {
8983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8984 }
8985 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8986 if (obj1) {
8987 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8988 if (!SWIG_IsOK(ecode2)) {
8989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8990 }
8991 arg2 = static_cast< size_t >(val2);
8992 }
8993 if (obj2) {
8994 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8995 if (!SWIG_IsOK(ecode3)) {
8996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8997 }
8998 arg3 = static_cast< size_t >(val3);
8999 }
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 {
9007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9008 }
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj = 0;
9017 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9018 size_t arg2 = (size_t) 0 ;
9019 size_t arg3 = (size_t) 1 ;
9020 bool result;
9021 void *argp1 = 0 ;
9022 int res1 = 0 ;
9023 size_t val2 ;
9024 int ecode2 = 0 ;
9025 size_t val3 ;
9026 int ecode3 = 0 ;
9027 PyObject * obj0 = 0 ;
9028 PyObject * obj1 = 0 ;
9029 PyObject * obj2 = 0 ;
9030 char * kwnames[] = {
9031 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9032 };
9033
9034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9036 if (!SWIG_IsOK(res1)) {
9037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9038 }
9039 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9040 if (obj1) {
9041 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9042 if (!SWIG_IsOK(ecode2)) {
9043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9044 }
9045 arg2 = static_cast< size_t >(val2);
9046 }
9047 if (obj2) {
9048 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9049 if (!SWIG_IsOK(ecode3)) {
9050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9051 }
9052 arg3 = static_cast< size_t >(val3);
9053 }
9054 {
9055 PyThreadState* __tstate = wxPyBeginAllowThreads();
9056 result = (bool)(arg1)->InsertCols(arg2,arg3);
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 {
9061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9062 }
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj = 0;
9071 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9072 size_t arg2 = (size_t) 1 ;
9073 bool result;
9074 void *argp1 = 0 ;
9075 int res1 = 0 ;
9076 size_t val2 ;
9077 int ecode2 = 0 ;
9078 PyObject * obj0 = 0 ;
9079 PyObject * obj1 = 0 ;
9080 char * kwnames[] = {
9081 (char *) "self",(char *) "numCols", NULL
9082 };
9083
9084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9088 }
9089 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9090 if (obj1) {
9091 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9092 if (!SWIG_IsOK(ecode2)) {
9093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9094 }
9095 arg2 = static_cast< size_t >(val2);
9096 }
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 result = (bool)(arg1)->AppendCols(arg2);
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9105 }
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj = 0;
9114 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9115 size_t arg2 = (size_t) 0 ;
9116 size_t arg3 = (size_t) 1 ;
9117 bool result;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 size_t val2 ;
9121 int ecode2 = 0 ;
9122 size_t val3 ;
9123 int ecode3 = 0 ;
9124 PyObject * obj0 = 0 ;
9125 PyObject * obj1 = 0 ;
9126 PyObject * obj2 = 0 ;
9127 char * kwnames[] = {
9128 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9129 };
9130
9131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9133 if (!SWIG_IsOK(res1)) {
9134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9135 }
9136 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9137 if (obj1) {
9138 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9139 if (!SWIG_IsOK(ecode2)) {
9140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9141 }
9142 arg2 = static_cast< size_t >(val2);
9143 }
9144 if (obj2) {
9145 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9146 if (!SWIG_IsOK(ecode3)) {
9147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9148 }
9149 arg3 = static_cast< size_t >(val3);
9150 }
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 {
9158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9159 }
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9167 PyObject *resultobj = 0;
9168 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9169 int arg2 ;
9170 wxString result;
9171 void *argp1 = 0 ;
9172 int res1 = 0 ;
9173 int val2 ;
9174 int ecode2 = 0 ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 char * kwnames[] = {
9178 (char *) "self",(char *) "row", NULL
9179 };
9180
9181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9183 if (!SWIG_IsOK(res1)) {
9184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9185 }
9186 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9187 ecode2 = SWIG_AsVal_int(obj1, &val2);
9188 if (!SWIG_IsOK(ecode2)) {
9189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9190 }
9191 arg2 = static_cast< int >(val2);
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 result = (arg1)->GetRowLabelValue(arg2);
9195 wxPyEndAllowThreads(__tstate);
9196 if (PyErr_Occurred()) SWIG_fail;
9197 }
9198 {
9199 #if wxUSE_UNICODE
9200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9201 #else
9202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9203 #endif
9204 }
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj = 0;
9213 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9214 int arg2 ;
9215 wxString result;
9216 void *argp1 = 0 ;
9217 int res1 = 0 ;
9218 int val2 ;
9219 int ecode2 = 0 ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 char * kwnames[] = {
9223 (char *) "self",(char *) "col", NULL
9224 };
9225
9226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9228 if (!SWIG_IsOK(res1)) {
9229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9230 }
9231 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9232 ecode2 = SWIG_AsVal_int(obj1, &val2);
9233 if (!SWIG_IsOK(ecode2)) {
9234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9235 }
9236 arg2 = static_cast< int >(val2);
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (arg1)->GetColLabelValue(arg2);
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 {
9244 #if wxUSE_UNICODE
9245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9246 #else
9247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9248 #endif
9249 }
9250 return resultobj;
9251 fail:
9252 return NULL;
9253 }
9254
9255
9256 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9257 PyObject *resultobj = 0;
9258 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9259 int arg2 ;
9260 wxString *arg3 = 0 ;
9261 void *argp1 = 0 ;
9262 int res1 = 0 ;
9263 int val2 ;
9264 int ecode2 = 0 ;
9265 bool temp3 = false ;
9266 PyObject * obj0 = 0 ;
9267 PyObject * obj1 = 0 ;
9268 PyObject * obj2 = 0 ;
9269 char * kwnames[] = {
9270 (char *) "self",(char *) "row",(char *) "value", NULL
9271 };
9272
9273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9275 if (!SWIG_IsOK(res1)) {
9276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9277 }
9278 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9279 ecode2 = SWIG_AsVal_int(obj1, &val2);
9280 if (!SWIG_IsOK(ecode2)) {
9281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9282 }
9283 arg2 = static_cast< int >(val2);
9284 {
9285 arg3 = wxString_in_helper(obj2);
9286 if (arg3 == NULL) SWIG_fail;
9287 temp3 = true;
9288 }
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_Py_Void();
9296 {
9297 if (temp3)
9298 delete arg3;
9299 }
9300 return resultobj;
9301 fail:
9302 {
9303 if (temp3)
9304 delete arg3;
9305 }
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9311 PyObject *resultobj = 0;
9312 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9313 int arg2 ;
9314 wxString *arg3 = 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 int val2 ;
9318 int ecode2 = 0 ;
9319 bool temp3 = false ;
9320 PyObject * obj0 = 0 ;
9321 PyObject * obj1 = 0 ;
9322 PyObject * obj2 = 0 ;
9323 char * kwnames[] = {
9324 (char *) "self",(char *) "col",(char *) "value", NULL
9325 };
9326
9327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9329 if (!SWIG_IsOK(res1)) {
9330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9331 }
9332 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9333 ecode2 = SWIG_AsVal_int(obj1, &val2);
9334 if (!SWIG_IsOK(ecode2)) {
9335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9336 }
9337 arg2 = static_cast< int >(val2);
9338 {
9339 arg3 = wxString_in_helper(obj2);
9340 if (arg3 == NULL) SWIG_fail;
9341 temp3 = true;
9342 }
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 resultobj = SWIG_Py_Void();
9350 {
9351 if (temp3)
9352 delete arg3;
9353 }
9354 return resultobj;
9355 fail:
9356 {
9357 if (temp3)
9358 delete arg3;
9359 }
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 PyObject *resultobj = 0;
9366 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9367 bool result;
9368 void *argp1 = 0 ;
9369 int res1 = 0 ;
9370 PyObject *swig_obj[1] ;
9371
9372 if (!args) SWIG_fail;
9373 swig_obj[0] = args;
9374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9377 }
9378 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 result = (bool)(arg1)->CanHaveAttributes();
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 {
9386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9387 }
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj = 0;
9396 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9397 int arg2 ;
9398 int arg3 ;
9399 wxGridCellAttr::wxAttrKind arg4 ;
9400 wxGridCellAttr *result = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 int val2 ;
9404 int ecode2 = 0 ;
9405 int val3 ;
9406 int ecode3 = 0 ;
9407 int val4 ;
9408 int ecode4 = 0 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 PyObject * obj2 = 0 ;
9412 PyObject * obj3 = 0 ;
9413 char * kwnames[] = {
9414 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9415 };
9416
9417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9419 if (!SWIG_IsOK(res1)) {
9420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9421 }
9422 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9423 ecode2 = SWIG_AsVal_int(obj1, &val2);
9424 if (!SWIG_IsOK(ecode2)) {
9425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9426 }
9427 arg2 = static_cast< int >(val2);
9428 ecode3 = SWIG_AsVal_int(obj2, &val3);
9429 if (!SWIG_IsOK(ecode3)) {
9430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9431 }
9432 arg3 = static_cast< int >(val3);
9433 ecode4 = SWIG_AsVal_int(obj3, &val4);
9434 if (!SWIG_IsOK(ecode4)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9436 }
9437 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 {
9445 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9446 }
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9456 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9457 int arg3 ;
9458 int arg4 ;
9459 void *argp1 = 0 ;
9460 int res1 = 0 ;
9461 void *argp2 = 0 ;
9462 int res2 = 0 ;
9463 int val3 ;
9464 int ecode3 = 0 ;
9465 int val4 ;
9466 int ecode4 = 0 ;
9467 PyObject * obj0 = 0 ;
9468 PyObject * obj1 = 0 ;
9469 PyObject * obj2 = 0 ;
9470 PyObject * obj3 = 0 ;
9471 char * kwnames[] = {
9472 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9473 };
9474
9475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9477 if (!SWIG_IsOK(res1)) {
9478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9479 }
9480 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9482 if (!SWIG_IsOK(res2)) {
9483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9484 }
9485 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9486 ecode3 = SWIG_AsVal_int(obj2, &val3);
9487 if (!SWIG_IsOK(ecode3)) {
9488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9489 }
9490 arg3 = static_cast< int >(val3);
9491 ecode4 = SWIG_AsVal_int(obj3, &val4);
9492 if (!SWIG_IsOK(ecode4)) {
9493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9494 }
9495 arg4 = static_cast< int >(val4);
9496 {
9497 PyThreadState* __tstate = wxPyBeginAllowThreads();
9498 (arg1)->SetAttr(arg2,arg3,arg4);
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 resultobj = SWIG_Py_Void();
9503 return resultobj;
9504 fail:
9505 return NULL;
9506 }
9507
9508
9509 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9510 PyObject *resultobj = 0;
9511 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9512 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9513 int arg3 ;
9514 void *argp1 = 0 ;
9515 int res1 = 0 ;
9516 void *argp2 = 0 ;
9517 int res2 = 0 ;
9518 int val3 ;
9519 int ecode3 = 0 ;
9520 PyObject * obj0 = 0 ;
9521 PyObject * obj1 = 0 ;
9522 PyObject * obj2 = 0 ;
9523 char * kwnames[] = {
9524 (char *) "self",(char *) "attr",(char *) "row", NULL
9525 };
9526
9527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9529 if (!SWIG_IsOK(res1)) {
9530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9531 }
9532 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9534 if (!SWIG_IsOK(res2)) {
9535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9536 }
9537 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9538 ecode3 = SWIG_AsVal_int(obj2, &val3);
9539 if (!SWIG_IsOK(ecode3)) {
9540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9541 }
9542 arg3 = static_cast< int >(val3);
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 (arg1)->SetRowAttr(arg2,arg3);
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = SWIG_Py_Void();
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9557 PyObject *resultobj = 0;
9558 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9559 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9560 int arg3 ;
9561 void *argp1 = 0 ;
9562 int res1 = 0 ;
9563 void *argp2 = 0 ;
9564 int res2 = 0 ;
9565 int val3 ;
9566 int ecode3 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 PyObject * obj2 = 0 ;
9570 char * kwnames[] = {
9571 (char *) "self",(char *) "attr",(char *) "col", NULL
9572 };
9573
9574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9576 if (!SWIG_IsOK(res1)) {
9577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9578 }
9579 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9583 }
9584 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9585 ecode3 = SWIG_AsVal_int(obj2, &val3);
9586 if (!SWIG_IsOK(ecode3)) {
9587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9588 }
9589 arg3 = static_cast< int >(val3);
9590 {
9591 PyThreadState* __tstate = wxPyBeginAllowThreads();
9592 (arg1)->SetColAttr(arg2,arg3);
9593 wxPyEndAllowThreads(__tstate);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9604 PyObject *obj;
9605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9606 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9607 return SWIG_Py_Void();
9608 }
9609
9610 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *resultobj = 0;
9612 wxPyGridTableBase *result = 0 ;
9613
9614 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9622 return resultobj;
9623 fail:
9624 return NULL;
9625 }
9626
9627
9628 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj = 0;
9630 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9631 PyObject *arg2 = (PyObject *) 0 ;
9632 PyObject *arg3 = (PyObject *) 0 ;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 PyObject * obj0 = 0 ;
9636 PyObject * obj1 = 0 ;
9637 PyObject * obj2 = 0 ;
9638 char * kwnames[] = {
9639 (char *) "self",(char *) "self",(char *) "_class", NULL
9640 };
9641
9642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9644 if (!SWIG_IsOK(res1)) {
9645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9646 }
9647 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9648 arg2 = obj1;
9649 arg3 = obj2;
9650 {
9651 PyThreadState* __tstate = wxPyBeginAllowThreads();
9652 (arg1)->_setCallbackInfo(arg2,arg3);
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_Py_Void();
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9664 PyObject *resultobj = 0;
9665 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9666 void *argp1 = 0 ;
9667 int res1 = 0 ;
9668 PyObject *swig_obj[1] ;
9669
9670 if (!args) SWIG_fail;
9671 swig_obj[0] = args;
9672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9675 }
9676 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 wxPyGridTableBase_Destroy(arg1);
9680 wxPyEndAllowThreads(__tstate);
9681 if (PyErr_Occurred()) SWIG_fail;
9682 }
9683 resultobj = SWIG_Py_Void();
9684 return resultobj;
9685 fail:
9686 return NULL;
9687 }
9688
9689
9690 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9691 PyObject *obj;
9692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9693 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9694 return SWIG_Py_Void();
9695 }
9696
9697 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 return SWIG_Python_InitShadowInstance(args);
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 int arg1 = (int) 0 ;
9704 int arg2 = (int) 0 ;
9705 wxGridStringTable *result = 0 ;
9706 int val1 ;
9707 int ecode1 = 0 ;
9708 int val2 ;
9709 int ecode2 = 0 ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char * kwnames[] = {
9713 (char *) "numRows",(char *) "numCols", NULL
9714 };
9715
9716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9717 if (obj0) {
9718 ecode1 = SWIG_AsVal_int(obj0, &val1);
9719 if (!SWIG_IsOK(ecode1)) {
9720 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9721 }
9722 arg1 = static_cast< int >(val1);
9723 }
9724 if (obj1) {
9725 ecode2 = SWIG_AsVal_int(obj1, &val2);
9726 if (!SWIG_IsOK(ecode2)) {
9727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9728 }
9729 arg2 = static_cast< int >(val2);
9730 }
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *obj;
9746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9747 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9748 return SWIG_Py_Void();
9749 }
9750
9751 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 return SWIG_Python_InitShadowInstance(args);
9753 }
9754
9755 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj = 0;
9757 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9758 int arg2 ;
9759 int arg3 = (int) -1 ;
9760 int arg4 = (int) -1 ;
9761 wxGridTableMessage *result = 0 ;
9762 void *argp1 = 0 ;
9763 int res1 = 0 ;
9764 int val2 ;
9765 int ecode2 = 0 ;
9766 int val3 ;
9767 int ecode3 = 0 ;
9768 int val4 ;
9769 int ecode4 = 0 ;
9770 PyObject * obj0 = 0 ;
9771 PyObject * obj1 = 0 ;
9772 PyObject * obj2 = 0 ;
9773 PyObject * obj3 = 0 ;
9774 char * kwnames[] = {
9775 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9776 };
9777
9778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9780 if (!SWIG_IsOK(res1)) {
9781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9782 }
9783 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9784 ecode2 = SWIG_AsVal_int(obj1, &val2);
9785 if (!SWIG_IsOK(ecode2)) {
9786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9787 }
9788 arg2 = static_cast< int >(val2);
9789 if (obj2) {
9790 ecode3 = SWIG_AsVal_int(obj2, &val3);
9791 if (!SWIG_IsOK(ecode3)) {
9792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9793 }
9794 arg3 = static_cast< int >(val3);
9795 }
9796 if (obj3) {
9797 ecode4 = SWIG_AsVal_int(obj3, &val4);
9798 if (!SWIG_IsOK(ecode4)) {
9799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9800 }
9801 arg4 = static_cast< int >(val4);
9802 }
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9828 }
9829 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 delete arg1;
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_Py_Void();
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9845 PyObject *resultobj = 0;
9846 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9847 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9848 void *argp1 = 0 ;
9849 int res1 = 0 ;
9850 void *argp2 = 0 ;
9851 int res2 = 0 ;
9852 PyObject * obj0 = 0 ;
9853 PyObject * obj1 = 0 ;
9854 char * kwnames[] = {
9855 (char *) "self",(char *) "table", NULL
9856 };
9857
9858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9862 }
9863 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9865 if (!SWIG_IsOK(res2)) {
9866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9867 }
9868 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 (arg1)->SetTableObject(arg2);
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 resultobj = SWIG_Py_Void();
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 PyObject *resultobj = 0;
9884 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9885 wxGridTableBase *result = 0 ;
9886 void *argp1 = 0 ;
9887 int res1 = 0 ;
9888 PyObject *swig_obj[1] ;
9889
9890 if (!args) SWIG_fail;
9891 swig_obj[0] = args;
9892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9893 if (!SWIG_IsOK(res1)) {
9894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9895 }
9896 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 {
9904 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9905 }
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9913 PyObject *resultobj = 0;
9914 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9915 int arg2 ;
9916 void *argp1 = 0 ;
9917 int res1 = 0 ;
9918 int val2 ;
9919 int ecode2 = 0 ;
9920 PyObject * obj0 = 0 ;
9921 PyObject * obj1 = 0 ;
9922 char * kwnames[] = {
9923 (char *) "self",(char *) "id", NULL
9924 };
9925
9926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9930 }
9931 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9932 ecode2 = SWIG_AsVal_int(obj1, &val2);
9933 if (!SWIG_IsOK(ecode2)) {
9934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9935 }
9936 arg2 = static_cast< int >(val2);
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 (arg1)->SetId(arg2);
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 resultobj = SWIG_Py_Void();
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 PyObject *resultobj = 0;
9952 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9953 int result;
9954 void *argp1 = 0 ;
9955 int res1 = 0 ;
9956 PyObject *swig_obj[1] ;
9957
9958 if (!args) SWIG_fail;
9959 swig_obj[0] = args;
9960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9961 if (!SWIG_IsOK(res1)) {
9962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9963 }
9964 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9965 {
9966 PyThreadState* __tstate = wxPyBeginAllowThreads();
9967 result = (int)(arg1)->GetId();
9968 wxPyEndAllowThreads(__tstate);
9969 if (PyErr_Occurred()) SWIG_fail;
9970 }
9971 resultobj = SWIG_From_int(static_cast< int >(result));
9972 return resultobj;
9973 fail:
9974 return NULL;
9975 }
9976
9977
9978 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9979 PyObject *resultobj = 0;
9980 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9981 int arg2 ;
9982 void *argp1 = 0 ;
9983 int res1 = 0 ;
9984 int val2 ;
9985 int ecode2 = 0 ;
9986 PyObject * obj0 = 0 ;
9987 PyObject * obj1 = 0 ;
9988 char * kwnames[] = {
9989 (char *) "self",(char *) "comInt1", NULL
9990 };
9991
9992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9994 if (!SWIG_IsOK(res1)) {
9995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9996 }
9997 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9998 ecode2 = SWIG_AsVal_int(obj1, &val2);
9999 if (!SWIG_IsOK(ecode2)) {
10000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10001 }
10002 arg2 = static_cast< int >(val2);
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 (arg1)->SetCommandInt(arg2);
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 resultobj = SWIG_Py_Void();
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10017 PyObject *resultobj = 0;
10018 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10019 int result;
10020 void *argp1 = 0 ;
10021 int res1 = 0 ;
10022 PyObject *swig_obj[1] ;
10023
10024 if (!args) SWIG_fail;
10025 swig_obj[0] = args;
10026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10027 if (!SWIG_IsOK(res1)) {
10028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10029 }
10030 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (int)(arg1)->GetCommandInt();
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 resultobj = SWIG_From_int(static_cast< int >(result));
10038 return resultobj;
10039 fail:
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10047 int arg2 ;
10048 void *argp1 = 0 ;
10049 int res1 = 0 ;
10050 int val2 ;
10051 int ecode2 = 0 ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "comInt2", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10062 }
10063 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10064 ecode2 = SWIG_AsVal_int(obj1, &val2);
10065 if (!SWIG_IsOK(ecode2)) {
10066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10067 }
10068 arg2 = static_cast< int >(val2);
10069 {
10070 PyThreadState* __tstate = wxPyBeginAllowThreads();
10071 (arg1)->SetCommandInt2(arg2);
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 resultobj = SWIG_Py_Void();
10076 return resultobj;
10077 fail:
10078 return NULL;
10079 }
10080
10081
10082 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10083 PyObject *resultobj = 0;
10084 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10085 int result;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 PyObject *swig_obj[1] ;
10089
10090 if (!args) SWIG_fail;
10091 swig_obj[0] = args;
10092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10093 if (!SWIG_IsOK(res1)) {
10094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10095 }
10096 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10097 {
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 result = (int)(arg1)->GetCommandInt2();
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 resultobj = SWIG_From_int(static_cast< int >(result));
10104 return resultobj;
10105 fail:
10106 return NULL;
10107 }
10108
10109
10110 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10111 PyObject *obj;
10112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10113 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10114 return SWIG_Py_Void();
10115 }
10116
10117 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 return SWIG_Python_InitShadowInstance(args);
10119 }
10120
10121 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj = 0;
10123 int arg1 = (int) -1 ;
10124 int arg2 = (int) -1 ;
10125 wxGridCellCoords *result = 0 ;
10126 int val1 ;
10127 int ecode1 = 0 ;
10128 int val2 ;
10129 int ecode2 = 0 ;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 char * kwnames[] = {
10133 (char *) "r",(char *) "c", NULL
10134 };
10135
10136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10137 if (obj0) {
10138 ecode1 = SWIG_AsVal_int(obj0, &val1);
10139 if (!SWIG_IsOK(ecode1)) {
10140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10141 }
10142 arg1 = static_cast< int >(val1);
10143 }
10144 if (obj1) {
10145 ecode2 = SWIG_AsVal_int(obj1, &val2);
10146 if (!SWIG_IsOK(ecode2)) {
10147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10148 }
10149 arg2 = static_cast< int >(val2);
10150 }
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10158 return resultobj;
10159 fail:
10160 return NULL;
10161 }
10162
10163
10164 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10165 PyObject *resultobj = 0;
10166 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 PyObject *swig_obj[1] ;
10170
10171 if (!args) SWIG_fail;
10172 swig_obj[0] = args;
10173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10174 if (!SWIG_IsOK(res1)) {
10175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10176 }
10177 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10178 {
10179 PyThreadState* __tstate = wxPyBeginAllowThreads();
10180 delete arg1;
10181
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 resultobj = SWIG_Py_Void();
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10193 PyObject *resultobj = 0;
10194 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10195 int result;
10196 void *argp1 = 0 ;
10197 int res1 = 0 ;
10198 PyObject *swig_obj[1] ;
10199
10200 if (!args) SWIG_fail;
10201 swig_obj[0] = args;
10202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10203 if (!SWIG_IsOK(res1)) {
10204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10205 }
10206 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10207 {
10208 PyThreadState* __tstate = wxPyBeginAllowThreads();
10209 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 resultobj = SWIG_From_int(static_cast< int >(result));
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj = 0;
10222 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10223 int arg2 ;
10224 void *argp1 = 0 ;
10225 int res1 = 0 ;
10226 int val2 ;
10227 int ecode2 = 0 ;
10228 PyObject * obj0 = 0 ;
10229 PyObject * obj1 = 0 ;
10230 char * kwnames[] = {
10231 (char *) "self",(char *) "n", NULL
10232 };
10233
10234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10236 if (!SWIG_IsOK(res1)) {
10237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10238 }
10239 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10240 ecode2 = SWIG_AsVal_int(obj1, &val2);
10241 if (!SWIG_IsOK(ecode2)) {
10242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10243 }
10244 arg2 = static_cast< int >(val2);
10245 {
10246 PyThreadState* __tstate = wxPyBeginAllowThreads();
10247 (arg1)->SetRow(arg2);
10248 wxPyEndAllowThreads(__tstate);
10249 if (PyErr_Occurred()) SWIG_fail;
10250 }
10251 resultobj = SWIG_Py_Void();
10252 return resultobj;
10253 fail:
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10259 PyObject *resultobj = 0;
10260 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10261 int result;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 PyObject *swig_obj[1] ;
10265
10266 if (!args) SWIG_fail;
10267 swig_obj[0] = args;
10268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10271 }
10272 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 resultobj = SWIG_From_int(static_cast< int >(result));
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10289 int arg2 ;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 int val2 ;
10293 int ecode2 = 0 ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "n", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10304 }
10305 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10306 ecode2 = SWIG_AsVal_int(obj1, &val2);
10307 if (!SWIG_IsOK(ecode2)) {
10308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10309 }
10310 arg2 = static_cast< int >(val2);
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 (arg1)->SetCol(arg2);
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 resultobj = SWIG_Py_Void();
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10325 PyObject *resultobj = 0;
10326 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10327 int arg2 ;
10328 int arg3 ;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 int val2 ;
10332 int ecode2 = 0 ;
10333 int val3 ;
10334 int ecode3 = 0 ;
10335 PyObject * obj0 = 0 ;
10336 PyObject * obj1 = 0 ;
10337 PyObject * obj2 = 0 ;
10338 char * kwnames[] = {
10339 (char *) "self",(char *) "row",(char *) "col", NULL
10340 };
10341
10342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10344 if (!SWIG_IsOK(res1)) {
10345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10346 }
10347 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10348 ecode2 = SWIG_AsVal_int(obj1, &val2);
10349 if (!SWIG_IsOK(ecode2)) {
10350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10351 }
10352 arg2 = static_cast< int >(val2);
10353 ecode3 = SWIG_AsVal_int(obj2, &val3);
10354 if (!SWIG_IsOK(ecode3)) {
10355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10356 }
10357 arg3 = static_cast< int >(val3);
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 (arg1)->Set(arg2,arg3);
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 resultobj = SWIG_Py_Void();
10365 return resultobj;
10366 fail:
10367 return NULL;
10368 }
10369
10370
10371 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10372 PyObject *resultobj = 0;
10373 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10374 PyObject *arg2 = (PyObject *) 0 ;
10375 bool result;
10376 void *argp1 = 0 ;
10377 int res1 = 0 ;
10378 PyObject * obj0 = 0 ;
10379 PyObject * obj1 = 0 ;
10380 char * kwnames[] = {
10381 (char *) "self",(char *) "other", NULL
10382 };
10383
10384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10386 if (!SWIG_IsOK(res1)) {
10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10388 }
10389 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10390 arg2 = obj1;
10391 {
10392 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 {
10396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10397 }
10398 return resultobj;
10399 fail:
10400 return NULL;
10401 }
10402
10403
10404 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj = 0;
10406 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10407 PyObject *arg2 = (PyObject *) 0 ;
10408 bool result;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 PyObject * obj0 = 0 ;
10412 PyObject * obj1 = 0 ;
10413 char * kwnames[] = {
10414 (char *) "self",(char *) "other", NULL
10415 };
10416
10417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10421 }
10422 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10423 arg2 = obj1;
10424 {
10425 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10426 if (PyErr_Occurred()) SWIG_fail;
10427 }
10428 {
10429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10430 }
10431 return resultobj;
10432 fail:
10433 return NULL;
10434 }
10435
10436
10437 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10438 PyObject *resultobj = 0;
10439 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10440 PyObject *result = 0 ;
10441 void *argp1 = 0 ;
10442 int res1 = 0 ;
10443 PyObject *swig_obj[1] ;
10444
10445 if (!args) SWIG_fail;
10446 swig_obj[0] = args;
10447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10448 if (!SWIG_IsOK(res1)) {
10449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10450 }
10451 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 result = (PyObject *)wxGridCellCoords_Get(arg1);
10455 wxPyEndAllowThreads(__tstate);
10456 if (PyErr_Occurred()) SWIG_fail;
10457 }
10458 resultobj = result;
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 PyObject *obj;
10467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10468 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10469 return SWIG_Py_Void();
10470 }
10471
10472 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10473 return SWIG_Python_InitShadowInstance(args);
10474 }
10475
10476 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj = 0;
10478 wxWindow *arg1 = (wxWindow *) 0 ;
10479 int arg2 = (int) -1 ;
10480 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10481 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10482 wxSize const &arg4_defvalue = wxDefaultSize ;
10483 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10484 long arg5 = (long) wxWANTS_CHARS ;
10485 wxString const &arg6_defvalue = wxPyGridNameStr ;
10486 wxString *arg6 = (wxString *) &arg6_defvalue ;
10487 wxGrid *result = 0 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 int val2 ;
10491 int ecode2 = 0 ;
10492 wxPoint temp3 ;
10493 wxSize temp4 ;
10494 long val5 ;
10495 int ecode5 = 0 ;
10496 bool temp6 = false ;
10497 PyObject * obj0 = 0 ;
10498 PyObject * obj1 = 0 ;
10499 PyObject * obj2 = 0 ;
10500 PyObject * obj3 = 0 ;
10501 PyObject * obj4 = 0 ;
10502 PyObject * obj5 = 0 ;
10503 char * kwnames[] = {
10504 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10505 };
10506
10507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10509 if (!SWIG_IsOK(res1)) {
10510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10511 }
10512 arg1 = reinterpret_cast< wxWindow * >(argp1);
10513 if (obj1) {
10514 ecode2 = SWIG_AsVal_int(obj1, &val2);
10515 if (!SWIG_IsOK(ecode2)) {
10516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10517 }
10518 arg2 = static_cast< int >(val2);
10519 }
10520 if (obj2) {
10521 {
10522 arg3 = &temp3;
10523 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10524 }
10525 }
10526 if (obj3) {
10527 {
10528 arg4 = &temp4;
10529 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10530 }
10531 }
10532 if (obj4) {
10533 ecode5 = SWIG_AsVal_long(obj4, &val5);
10534 if (!SWIG_IsOK(ecode5)) {
10535 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10536 }
10537 arg5 = static_cast< long >(val5);
10538 }
10539 if (obj5) {
10540 {
10541 arg6 = wxString_in_helper(obj5);
10542 if (arg6 == NULL) SWIG_fail;
10543 temp6 = true;
10544 }
10545 }
10546 {
10547 if (!wxPyCheckForApp()) SWIG_fail;
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10554 {
10555 if (temp6)
10556 delete arg6;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp6)
10562 delete arg6;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxGrid *result = 0 ;
10571
10572 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10573 {
10574 if (!wxPyCheckForApp()) SWIG_fail;
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (wxGrid *)new wxGrid();
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj = 0;
10589 wxGrid *arg1 = (wxGrid *) 0 ;
10590 wxWindow *arg2 = (wxWindow *) 0 ;
10591 int arg3 = (int) -1 ;
10592 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10593 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10594 wxSize const &arg5_defvalue = wxDefaultSize ;
10595 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10596 long arg6 = (long) wxWANTS_CHARS ;
10597 wxString const &arg7_defvalue = wxPyGridNameStr ;
10598 wxString *arg7 = (wxString *) &arg7_defvalue ;
10599 bool result;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 void *argp2 = 0 ;
10603 int res2 = 0 ;
10604 int val3 ;
10605 int ecode3 = 0 ;
10606 wxPoint temp4 ;
10607 wxSize temp5 ;
10608 long val6 ;
10609 int ecode6 = 0 ;
10610 bool temp7 = false ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 PyObject * obj2 = 0 ;
10614 PyObject * obj3 = 0 ;
10615 PyObject * obj4 = 0 ;
10616 PyObject * obj5 = 0 ;
10617 PyObject * obj6 = 0 ;
10618 char * kwnames[] = {
10619 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10620 };
10621
10622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10624 if (!SWIG_IsOK(res1)) {
10625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10626 }
10627 arg1 = reinterpret_cast< wxGrid * >(argp1);
10628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10629 if (!SWIG_IsOK(res2)) {
10630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10631 }
10632 arg2 = reinterpret_cast< wxWindow * >(argp2);
10633 if (obj2) {
10634 ecode3 = SWIG_AsVal_int(obj2, &val3);
10635 if (!SWIG_IsOK(ecode3)) {
10636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10637 }
10638 arg3 = static_cast< int >(val3);
10639 }
10640 if (obj3) {
10641 {
10642 arg4 = &temp4;
10643 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10644 }
10645 }
10646 if (obj4) {
10647 {
10648 arg5 = &temp5;
10649 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10650 }
10651 }
10652 if (obj5) {
10653 ecode6 = SWIG_AsVal_long(obj5, &val6);
10654 if (!SWIG_IsOK(ecode6)) {
10655 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10656 }
10657 arg6 = static_cast< long >(val6);
10658 }
10659 if (obj6) {
10660 {
10661 arg7 = wxString_in_helper(obj6);
10662 if (arg7 == NULL) SWIG_fail;
10663 temp7 = true;
10664 }
10665 }
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 {
10673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10674 }
10675 {
10676 if (temp7)
10677 delete arg7;
10678 }
10679 return resultobj;
10680 fail:
10681 {
10682 if (temp7)
10683 delete arg7;
10684 }
10685 return NULL;
10686 }
10687
10688
10689 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10690 PyObject *resultobj = 0;
10691 wxGrid *arg1 = (wxGrid *) 0 ;
10692 int arg2 ;
10693 int arg3 ;
10694 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10695 bool result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 int val2 ;
10699 int ecode2 = 0 ;
10700 int val3 ;
10701 int ecode3 = 0 ;
10702 int val4 ;
10703 int ecode4 = 0 ;
10704 PyObject * obj0 = 0 ;
10705 PyObject * obj1 = 0 ;
10706 PyObject * obj2 = 0 ;
10707 PyObject * obj3 = 0 ;
10708 char * kwnames[] = {
10709 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10710 };
10711
10712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10714 if (!SWIG_IsOK(res1)) {
10715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10716 }
10717 arg1 = reinterpret_cast< wxGrid * >(argp1);
10718 ecode2 = SWIG_AsVal_int(obj1, &val2);
10719 if (!SWIG_IsOK(ecode2)) {
10720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10721 }
10722 arg2 = static_cast< int >(val2);
10723 ecode3 = SWIG_AsVal_int(obj2, &val3);
10724 if (!SWIG_IsOK(ecode3)) {
10725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10726 }
10727 arg3 = static_cast< int >(val3);
10728 if (obj3) {
10729 ecode4 = SWIG_AsVal_int(obj3, &val4);
10730 if (!SWIG_IsOK(ecode4)) {
10731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10732 }
10733 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10734 }
10735 {
10736 PyThreadState* __tstate = wxPyBeginAllowThreads();
10737 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10738 wxPyEndAllowThreads(__tstate);
10739 if (PyErr_Occurred()) SWIG_fail;
10740 }
10741 {
10742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10743 }
10744 return resultobj;
10745 fail:
10746 return NULL;
10747 }
10748
10749
10750 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj = 0;
10752 wxGrid *arg1 = (wxGrid *) 0 ;
10753 WXGRIDSELECTIONMODES arg2 ;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 int val2 ;
10757 int ecode2 = 0 ;
10758 PyObject * obj0 = 0 ;
10759 PyObject * obj1 = 0 ;
10760 char * kwnames[] = {
10761 (char *) "self",(char *) "selmode", NULL
10762 };
10763
10764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10768 }
10769 arg1 = reinterpret_cast< wxGrid * >(argp1);
10770 ecode2 = SWIG_AsVal_int(obj1, &val2);
10771 if (!SWIG_IsOK(ecode2)) {
10772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10773 }
10774 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 (arg1)->SetSelectionMode(arg2);
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = SWIG_Py_Void();
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10789 PyObject *resultobj = 0;
10790 wxGrid *arg1 = (wxGrid *) 0 ;
10791 WXGRIDSELECTIONMODES result;
10792 void *argp1 = 0 ;
10793 int res1 = 0 ;
10794 PyObject *swig_obj[1] ;
10795
10796 if (!args) SWIG_fail;
10797 swig_obj[0] = args;
10798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10801 }
10802 arg1 = reinterpret_cast< wxGrid * >(argp1);
10803 {
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10806 wxPyEndAllowThreads(__tstate);
10807 if (PyErr_Occurred()) SWIG_fail;
10808 }
10809 resultobj = SWIG_From_int(static_cast< int >(result));
10810 return resultobj;
10811 fail:
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10817 PyObject *resultobj = 0;
10818 wxGrid *arg1 = (wxGrid *) 0 ;
10819 int result;
10820 void *argp1 = 0 ;
10821 int res1 = 0 ;
10822 PyObject *swig_obj[1] ;
10823
10824 if (!args) SWIG_fail;
10825 swig_obj[0] = args;
10826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10827 if (!SWIG_IsOK(res1)) {
10828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10829 }
10830 arg1 = reinterpret_cast< wxGrid * >(argp1);
10831 {
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 result = (int)(arg1)->GetNumberRows();
10834 wxPyEndAllowThreads(__tstate);
10835 if (PyErr_Occurred()) SWIG_fail;
10836 }
10837 resultobj = SWIG_From_int(static_cast< int >(result));
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10845 PyObject *resultobj = 0;
10846 wxGrid *arg1 = (wxGrid *) 0 ;
10847 int result;
10848 void *argp1 = 0 ;
10849 int res1 = 0 ;
10850 PyObject *swig_obj[1] ;
10851
10852 if (!args) SWIG_fail;
10853 swig_obj[0] = args;
10854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10857 }
10858 arg1 = reinterpret_cast< wxGrid * >(argp1);
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = (int)(arg1)->GetNumberCols();
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 resultobj = SWIG_From_int(static_cast< int >(result));
10866 return resultobj;
10867 fail:
10868 return NULL;
10869 }
10870
10871
10872 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj = 0;
10874 wxGrid *arg1 = (wxGrid *) 0 ;
10875 wxGridTableMessage *arg2 = 0 ;
10876 bool result;
10877 void *argp1 = 0 ;
10878 int res1 = 0 ;
10879 void *argp2 = 0 ;
10880 int res2 = 0 ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 char * kwnames[] = {
10884 (char *) "self",(char *)"arg2", NULL
10885 };
10886
10887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10889 if (!SWIG_IsOK(res1)) {
10890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10891 }
10892 arg1 = reinterpret_cast< wxGrid * >(argp1);
10893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10894 if (!SWIG_IsOK(res2)) {
10895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10896 }
10897 if (!argp2) {
10898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10899 }
10900 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 {
10908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10909 }
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10917 PyObject *resultobj = 0;
10918 wxGrid *arg1 = (wxGrid *) 0 ;
10919 wxGridTableBase *result = 0 ;
10920 void *argp1 = 0 ;
10921 int res1 = 0 ;
10922 PyObject *swig_obj[1] ;
10923
10924 if (!args) SWIG_fail;
10925 swig_obj[0] = args;
10926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10927 if (!SWIG_IsOK(res1)) {
10928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10929 }
10930 arg1 = reinterpret_cast< wxGrid * >(argp1);
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10939 }
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = 0;
10948 wxGrid *arg1 = (wxGrid *) 0 ;
10949 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10950 bool arg3 = (bool) false ;
10951 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10952 bool result;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 int res2 = 0 ;
10956 bool val3 ;
10957 int ecode3 = 0 ;
10958 int val4 ;
10959 int ecode4 = 0 ;
10960 PyObject * obj0 = 0 ;
10961 PyObject * obj1 = 0 ;
10962 PyObject * obj2 = 0 ;
10963 PyObject * obj3 = 0 ;
10964 char * kwnames[] = {
10965 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10966 };
10967
10968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10970 if (!SWIG_IsOK(res1)) {
10971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10972 }
10973 arg1 = reinterpret_cast< wxGrid * >(argp1);
10974 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10975 if (!SWIG_IsOK(res2)) {
10976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10977 }
10978 if (obj2) {
10979 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10980 if (!SWIG_IsOK(ecode3)) {
10981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10982 }
10983 arg3 = static_cast< bool >(val3);
10984 }
10985 if (obj3) {
10986 ecode4 = SWIG_AsVal_int(obj3, &val4);
10987 if (!SWIG_IsOK(ecode4)) {
10988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10989 }
10990 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10991 }
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 {
10999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11000 }
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *resultobj = 0;
11009 wxGrid *arg1 = (wxGrid *) 0 ;
11010 void *argp1 = 0 ;
11011 int res1 = 0 ;
11012 PyObject *swig_obj[1] ;
11013
11014 if (!args) SWIG_fail;
11015 swig_obj[0] = args;
11016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11017 if (!SWIG_IsOK(res1)) {
11018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11019 }
11020 arg1 = reinterpret_cast< wxGrid * >(argp1);
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 (arg1)->ClearGrid();
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 resultobj = SWIG_Py_Void();
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj = 0;
11036 wxGrid *arg1 = (wxGrid *) 0 ;
11037 int arg2 = (int) 0 ;
11038 int arg3 = (int) 1 ;
11039 bool arg4 = (bool) true ;
11040 bool result;
11041 void *argp1 = 0 ;
11042 int res1 = 0 ;
11043 int val2 ;
11044 int ecode2 = 0 ;
11045 int val3 ;
11046 int ecode3 = 0 ;
11047 bool val4 ;
11048 int ecode4 = 0 ;
11049 PyObject * obj0 = 0 ;
11050 PyObject * obj1 = 0 ;
11051 PyObject * obj2 = 0 ;
11052 PyObject * obj3 = 0 ;
11053 char * kwnames[] = {
11054 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11055 };
11056
11057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11059 if (!SWIG_IsOK(res1)) {
11060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11061 }
11062 arg1 = reinterpret_cast< wxGrid * >(argp1);
11063 if (obj1) {
11064 ecode2 = SWIG_AsVal_int(obj1, &val2);
11065 if (!SWIG_IsOK(ecode2)) {
11066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11067 }
11068 arg2 = static_cast< int >(val2);
11069 }
11070 if (obj2) {
11071 ecode3 = SWIG_AsVal_int(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11074 }
11075 arg3 = static_cast< int >(val3);
11076 }
11077 if (obj3) {
11078 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11079 if (!SWIG_IsOK(ecode4)) {
11080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11081 }
11082 arg4 = static_cast< bool >(val4);
11083 }
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 {
11091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11092 }
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxGrid *arg1 = (wxGrid *) 0 ;
11102 int arg2 = (int) 1 ;
11103 bool arg3 = (bool) true ;
11104 bool result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 int val2 ;
11108 int ecode2 = 0 ;
11109 bool val3 ;
11110 int ecode3 = 0 ;
11111 PyObject * obj0 = 0 ;
11112 PyObject * obj1 = 0 ;
11113 PyObject * obj2 = 0 ;
11114 char * kwnames[] = {
11115 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11116 };
11117
11118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11120 if (!SWIG_IsOK(res1)) {
11121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11122 }
11123 arg1 = reinterpret_cast< wxGrid * >(argp1);
11124 if (obj1) {
11125 ecode2 = SWIG_AsVal_int(obj1, &val2);
11126 if (!SWIG_IsOK(ecode2)) {
11127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11128 }
11129 arg2 = static_cast< int >(val2);
11130 }
11131 if (obj2) {
11132 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11133 if (!SWIG_IsOK(ecode3)) {
11134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11135 }
11136 arg3 = static_cast< bool >(val3);
11137 }
11138 {
11139 PyThreadState* __tstate = wxPyBeginAllowThreads();
11140 result = (bool)(arg1)->AppendRows(arg2,arg3);
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 {
11145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11146 }
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11154 PyObject *resultobj = 0;
11155 wxGrid *arg1 = (wxGrid *) 0 ;
11156 int arg2 = (int) 0 ;
11157 int arg3 = (int) 1 ;
11158 bool arg4 = (bool) true ;
11159 bool result;
11160 void *argp1 = 0 ;
11161 int res1 = 0 ;
11162 int val2 ;
11163 int ecode2 = 0 ;
11164 int val3 ;
11165 int ecode3 = 0 ;
11166 bool val4 ;
11167 int ecode4 = 0 ;
11168 PyObject * obj0 = 0 ;
11169 PyObject * obj1 = 0 ;
11170 PyObject * obj2 = 0 ;
11171 PyObject * obj3 = 0 ;
11172 char * kwnames[] = {
11173 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11174 };
11175
11176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11178 if (!SWIG_IsOK(res1)) {
11179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11180 }
11181 arg1 = reinterpret_cast< wxGrid * >(argp1);
11182 if (obj1) {
11183 ecode2 = SWIG_AsVal_int(obj1, &val2);
11184 if (!SWIG_IsOK(ecode2)) {
11185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11186 }
11187 arg2 = static_cast< int >(val2);
11188 }
11189 if (obj2) {
11190 ecode3 = SWIG_AsVal_int(obj2, &val3);
11191 if (!SWIG_IsOK(ecode3)) {
11192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11193 }
11194 arg3 = static_cast< int >(val3);
11195 }
11196 if (obj3) {
11197 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11198 if (!SWIG_IsOK(ecode4)) {
11199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11200 }
11201 arg4 = static_cast< bool >(val4);
11202 }
11203 {
11204 PyThreadState* __tstate = wxPyBeginAllowThreads();
11205 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 {
11210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11211 }
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11219 PyObject *resultobj = 0;
11220 wxGrid *arg1 = (wxGrid *) 0 ;
11221 int arg2 = (int) 0 ;
11222 int arg3 = (int) 1 ;
11223 bool arg4 = (bool) true ;
11224 bool result;
11225 void *argp1 = 0 ;
11226 int res1 = 0 ;
11227 int val2 ;
11228 int ecode2 = 0 ;
11229 int val3 ;
11230 int ecode3 = 0 ;
11231 bool val4 ;
11232 int ecode4 = 0 ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 PyObject * obj3 = 0 ;
11237 char * kwnames[] = {
11238 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11239 };
11240
11241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11243 if (!SWIG_IsOK(res1)) {
11244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11245 }
11246 arg1 = reinterpret_cast< wxGrid * >(argp1);
11247 if (obj1) {
11248 ecode2 = SWIG_AsVal_int(obj1, &val2);
11249 if (!SWIG_IsOK(ecode2)) {
11250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11251 }
11252 arg2 = static_cast< int >(val2);
11253 }
11254 if (obj2) {
11255 ecode3 = SWIG_AsVal_int(obj2, &val3);
11256 if (!SWIG_IsOK(ecode3)) {
11257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11258 }
11259 arg3 = static_cast< int >(val3);
11260 }
11261 if (obj3) {
11262 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11263 if (!SWIG_IsOK(ecode4)) {
11264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11265 }
11266 arg4 = static_cast< bool >(val4);
11267 }
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 {
11275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11276 }
11277 return resultobj;
11278 fail:
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj = 0;
11285 wxGrid *arg1 = (wxGrid *) 0 ;
11286 int arg2 = (int) 1 ;
11287 bool arg3 = (bool) true ;
11288 bool result;
11289 void *argp1 = 0 ;
11290 int res1 = 0 ;
11291 int val2 ;
11292 int ecode2 = 0 ;
11293 bool val3 ;
11294 int ecode3 = 0 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 char * kwnames[] = {
11299 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11300 };
11301
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11304 if (!SWIG_IsOK(res1)) {
11305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11306 }
11307 arg1 = reinterpret_cast< wxGrid * >(argp1);
11308 if (obj1) {
11309 ecode2 = SWIG_AsVal_int(obj1, &val2);
11310 if (!SWIG_IsOK(ecode2)) {
11311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11312 }
11313 arg2 = static_cast< int >(val2);
11314 }
11315 if (obj2) {
11316 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11317 if (!SWIG_IsOK(ecode3)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11319 }
11320 arg3 = static_cast< bool >(val3);
11321 }
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 result = (bool)(arg1)->AppendCols(arg2,arg3);
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 {
11329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11330 }
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj = 0;
11339 wxGrid *arg1 = (wxGrid *) 0 ;
11340 int arg2 = (int) 0 ;
11341 int arg3 = (int) 1 ;
11342 bool arg4 = (bool) true ;
11343 bool result;
11344 void *argp1 = 0 ;
11345 int res1 = 0 ;
11346 int val2 ;
11347 int ecode2 = 0 ;
11348 int val3 ;
11349 int ecode3 = 0 ;
11350 bool val4 ;
11351 int ecode4 = 0 ;
11352 PyObject * obj0 = 0 ;
11353 PyObject * obj1 = 0 ;
11354 PyObject * obj2 = 0 ;
11355 PyObject * obj3 = 0 ;
11356 char * kwnames[] = {
11357 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11358 };
11359
11360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11362 if (!SWIG_IsOK(res1)) {
11363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11364 }
11365 arg1 = reinterpret_cast< wxGrid * >(argp1);
11366 if (obj1) {
11367 ecode2 = SWIG_AsVal_int(obj1, &val2);
11368 if (!SWIG_IsOK(ecode2)) {
11369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11370 }
11371 arg2 = static_cast< int >(val2);
11372 }
11373 if (obj2) {
11374 ecode3 = SWIG_AsVal_int(obj2, &val3);
11375 if (!SWIG_IsOK(ecode3)) {
11376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11377 }
11378 arg3 = static_cast< int >(val3);
11379 }
11380 if (obj3) {
11381 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11382 if (!SWIG_IsOK(ecode4)) {
11383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11384 }
11385 arg4 = static_cast< bool >(val4);
11386 }
11387 {
11388 PyThreadState* __tstate = wxPyBeginAllowThreads();
11389 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11390 wxPyEndAllowThreads(__tstate);
11391 if (PyErr_Occurred()) SWIG_fail;
11392 }
11393 {
11394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11395 }
11396 return resultobj;
11397 fail:
11398 return NULL;
11399 }
11400
11401
11402 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11403 PyObject *resultobj = 0;
11404 wxGrid *arg1 = (wxGrid *) 0 ;
11405 wxDC *arg2 = 0 ;
11406 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11407 void *argp1 = 0 ;
11408 int res1 = 0 ;
11409 void *argp2 = 0 ;
11410 int res2 = 0 ;
11411 void *argp3 = 0 ;
11412 int res3 = 0 ;
11413 PyObject * obj0 = 0 ;
11414 PyObject * obj1 = 0 ;
11415 PyObject * obj2 = 0 ;
11416 char * kwnames[] = {
11417 (char *) "self",(char *) "dc",(char *) "attr", NULL
11418 };
11419
11420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11422 if (!SWIG_IsOK(res1)) {
11423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11424 }
11425 arg1 = reinterpret_cast< wxGrid * >(argp1);
11426 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11427 if (!SWIG_IsOK(res2)) {
11428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11429 }
11430 if (!argp2) {
11431 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11432 }
11433 arg2 = reinterpret_cast< wxDC * >(argp2);
11434 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11435 if (!SWIG_IsOK(res3)) {
11436 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11437 }
11438 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11439 {
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 resultobj = SWIG_Py_Void();
11446 return resultobj;
11447 fail:
11448 return NULL;
11449 }
11450
11451
11452 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11453 PyObject *resultobj = 0;
11454 wxGrid *arg1 = (wxGrid *) 0 ;
11455 wxDC *arg2 = 0 ;
11456 wxString *arg3 = 0 ;
11457 wxRect *arg4 = 0 ;
11458 int arg5 = (int) wxLEFT ;
11459 int arg6 = (int) wxTOP ;
11460 int arg7 = (int) wxHORIZONTAL ;
11461 void *argp1 = 0 ;
11462 int res1 = 0 ;
11463 void *argp2 = 0 ;
11464 int res2 = 0 ;
11465 bool temp3 = false ;
11466 wxRect temp4 ;
11467 int val5 ;
11468 int ecode5 = 0 ;
11469 int val6 ;
11470 int ecode6 = 0 ;
11471 int val7 ;
11472 int ecode7 = 0 ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 PyObject * obj2 = 0 ;
11476 PyObject * obj3 = 0 ;
11477 PyObject * obj4 = 0 ;
11478 PyObject * obj5 = 0 ;
11479 PyObject * obj6 = 0 ;
11480 char * kwnames[] = {
11481 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11482 };
11483
11484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11486 if (!SWIG_IsOK(res1)) {
11487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11488 }
11489 arg1 = reinterpret_cast< wxGrid * >(argp1);
11490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11491 if (!SWIG_IsOK(res2)) {
11492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11493 }
11494 if (!argp2) {
11495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11496 }
11497 arg2 = reinterpret_cast< wxDC * >(argp2);
11498 {
11499 arg3 = wxString_in_helper(obj2);
11500 if (arg3 == NULL) SWIG_fail;
11501 temp3 = true;
11502 }
11503 {
11504 arg4 = &temp4;
11505 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11506 }
11507 if (obj4) {
11508 ecode5 = SWIG_AsVal_int(obj4, &val5);
11509 if (!SWIG_IsOK(ecode5)) {
11510 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11511 }
11512 arg5 = static_cast< int >(val5);
11513 }
11514 if (obj5) {
11515 ecode6 = SWIG_AsVal_int(obj5, &val6);
11516 if (!SWIG_IsOK(ecode6)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11518 }
11519 arg6 = static_cast< int >(val6);
11520 }
11521 if (obj6) {
11522 ecode7 = SWIG_AsVal_int(obj6, &val7);
11523 if (!SWIG_IsOK(ecode7)) {
11524 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11525 }
11526 arg7 = static_cast< int >(val7);
11527 }
11528 {
11529 PyThreadState* __tstate = wxPyBeginAllowThreads();
11530 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11531 wxPyEndAllowThreads(__tstate);
11532 if (PyErr_Occurred()) SWIG_fail;
11533 }
11534 resultobj = SWIG_Py_Void();
11535 {
11536 if (temp3)
11537 delete arg3;
11538 }
11539 return resultobj;
11540 fail:
11541 {
11542 if (temp3)
11543 delete arg3;
11544 }
11545 return NULL;
11546 }
11547
11548
11549 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj = 0;
11551 wxGrid *arg1 = (wxGrid *) 0 ;
11552 wxDC *arg2 = 0 ;
11553 wxArrayString *arg3 = 0 ;
11554 long *arg4 = (long *) 0 ;
11555 long *arg5 = (long *) 0 ;
11556 void *argp1 = 0 ;
11557 int res1 = 0 ;
11558 void *argp2 = 0 ;
11559 int res2 = 0 ;
11560 bool temp3 = false ;
11561 long temp4 ;
11562 int res4 = SWIG_TMPOBJ ;
11563 long temp5 ;
11564 int res5 = SWIG_TMPOBJ ;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 char * kwnames[] = {
11569 (char *) "self",(char *) "dc",(char *) "lines", NULL
11570 };
11571
11572 arg4 = &temp4;
11573 arg5 = &temp5;
11574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11576 if (!SWIG_IsOK(res1)) {
11577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11578 }
11579 arg1 = reinterpret_cast< wxGrid * >(argp1);
11580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11581 if (!SWIG_IsOK(res2)) {
11582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11583 }
11584 if (!argp2) {
11585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11586 }
11587 arg2 = reinterpret_cast< wxDC * >(argp2);
11588 {
11589 if (! PySequence_Check(obj2)) {
11590 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11591 SWIG_fail;
11592 }
11593 arg3 = new wxArrayString;
11594 temp3 = true;
11595 int i, len=PySequence_Length(obj2);
11596 for (i=0; i<len; i++) {
11597 PyObject* item = PySequence_GetItem(obj2, i);
11598 wxString* s = wxString_in_helper(item);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 arg3->Add(*s);
11601 delete s;
11602 Py_DECREF(item);
11603 }
11604 }
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 resultobj = SWIG_Py_Void();
11612 if (SWIG_IsTmpObj(res4)) {
11613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11614 } else {
11615 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11617 }
11618 if (SWIG_IsTmpObj(res5)) {
11619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11620 } else {
11621 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11623 }
11624 {
11625 if (temp3) delete arg3;
11626 }
11627 return resultobj;
11628 fail:
11629 {
11630 if (temp3) delete arg3;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxGrid *arg1 = (wxGrid *) 0 ;
11639 void *argp1 = 0 ;
11640 int res1 = 0 ;
11641 PyObject *swig_obj[1] ;
11642
11643 if (!args) SWIG_fail;
11644 swig_obj[0] = args;
11645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11646 if (!SWIG_IsOK(res1)) {
11647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11648 }
11649 arg1 = reinterpret_cast< wxGrid * >(argp1);
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 (arg1)->BeginBatch();
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 resultobj = SWIG_Py_Void();
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 PyObject *resultobj = 0;
11665 wxGrid *arg1 = (wxGrid *) 0 ;
11666 void *argp1 = 0 ;
11667 int res1 = 0 ;
11668 PyObject *swig_obj[1] ;
11669
11670 if (!args) SWIG_fail;
11671 swig_obj[0] = args;
11672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11673 if (!SWIG_IsOK(res1)) {
11674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11675 }
11676 arg1 = reinterpret_cast< wxGrid * >(argp1);
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 (arg1)->EndBatch();
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 resultobj = SWIG_Py_Void();
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11691 PyObject *resultobj = 0;
11692 wxGrid *arg1 = (wxGrid *) 0 ;
11693 int result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 PyObject *swig_obj[1] ;
11697
11698 if (!args) SWIG_fail;
11699 swig_obj[0] = args;
11700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11703 }
11704 arg1 = reinterpret_cast< wxGrid * >(argp1);
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (int)(arg1)->GetBatchCount();
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = SWIG_From_int(static_cast< int >(result));
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *resultobj = 0;
11720 wxGrid *arg1 = (wxGrid *) 0 ;
11721 void *argp1 = 0 ;
11722 int res1 = 0 ;
11723 PyObject *swig_obj[1] ;
11724
11725 if (!args) SWIG_fail;
11726 swig_obj[0] = args;
11727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11728 if (!SWIG_IsOK(res1)) {
11729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11730 }
11731 arg1 = reinterpret_cast< wxGrid * >(argp1);
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 (arg1)->ForceRefresh();
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 resultobj = SWIG_Py_Void();
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11746 PyObject *resultobj = 0;
11747 wxGrid *arg1 = (wxGrid *) 0 ;
11748 bool result;
11749 void *argp1 = 0 ;
11750 int res1 = 0 ;
11751 PyObject *swig_obj[1] ;
11752
11753 if (!args) SWIG_fail;
11754 swig_obj[0] = args;
11755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11756 if (!SWIG_IsOK(res1)) {
11757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11758 }
11759 arg1 = reinterpret_cast< wxGrid * >(argp1);
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 result = (bool)(arg1)->IsEditable();
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 {
11767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11768 }
11769 return resultobj;
11770 fail:
11771 return NULL;
11772 }
11773
11774
11775 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj = 0;
11777 wxGrid *arg1 = (wxGrid *) 0 ;
11778 bool arg2 ;
11779 void *argp1 = 0 ;
11780 int res1 = 0 ;
11781 bool val2 ;
11782 int ecode2 = 0 ;
11783 PyObject * obj0 = 0 ;
11784 PyObject * obj1 = 0 ;
11785 char * kwnames[] = {
11786 (char *) "self",(char *) "edit", NULL
11787 };
11788
11789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11791 if (!SWIG_IsOK(res1)) {
11792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11793 }
11794 arg1 = reinterpret_cast< wxGrid * >(argp1);
11795 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11796 if (!SWIG_IsOK(ecode2)) {
11797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11798 }
11799 arg2 = static_cast< bool >(val2);
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 (arg1)->EnableEditing(arg2);
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 resultobj = SWIG_Py_Void();
11807 return resultobj;
11808 fail:
11809 return NULL;
11810 }
11811
11812
11813 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11814 PyObject *resultobj = 0;
11815 wxGrid *arg1 = (wxGrid *) 0 ;
11816 bool arg2 = (bool) true ;
11817 void *argp1 = 0 ;
11818 int res1 = 0 ;
11819 bool val2 ;
11820 int ecode2 = 0 ;
11821 PyObject * obj0 = 0 ;
11822 PyObject * obj1 = 0 ;
11823 char * kwnames[] = {
11824 (char *) "self",(char *) "enable", NULL
11825 };
11826
11827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11831 }
11832 arg1 = reinterpret_cast< wxGrid * >(argp1);
11833 if (obj1) {
11834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11835 if (!SWIG_IsOK(ecode2)) {
11836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11837 }
11838 arg2 = static_cast< bool >(val2);
11839 }
11840 {
11841 PyThreadState* __tstate = wxPyBeginAllowThreads();
11842 (arg1)->EnableCellEditControl(arg2);
11843 wxPyEndAllowThreads(__tstate);
11844 if (PyErr_Occurred()) SWIG_fail;
11845 }
11846 resultobj = SWIG_Py_Void();
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11854 PyObject *resultobj = 0;
11855 wxGrid *arg1 = (wxGrid *) 0 ;
11856 void *argp1 = 0 ;
11857 int res1 = 0 ;
11858 PyObject *swig_obj[1] ;
11859
11860 if (!args) SWIG_fail;
11861 swig_obj[0] = args;
11862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11863 if (!SWIG_IsOK(res1)) {
11864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11865 }
11866 arg1 = reinterpret_cast< wxGrid * >(argp1);
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 (arg1)->DisableCellEditControl();
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 resultobj = SWIG_Py_Void();
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11881 PyObject *resultobj = 0;
11882 wxGrid *arg1 = (wxGrid *) 0 ;
11883 bool result;
11884 void *argp1 = 0 ;
11885 int res1 = 0 ;
11886 PyObject *swig_obj[1] ;
11887
11888 if (!args) SWIG_fail;
11889 swig_obj[0] = args;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11893 }
11894 arg1 = reinterpret_cast< wxGrid * >(argp1);
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11911 PyObject *resultobj = 0;
11912 wxGrid *arg1 = (wxGrid *) 0 ;
11913 bool result;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 PyObject *swig_obj[1] ;
11917
11918 if (!args) SWIG_fail;
11919 swig_obj[0] = args;
11920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11921 if (!SWIG_IsOK(res1)) {
11922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11923 }
11924 arg1 = reinterpret_cast< wxGrid * >(argp1);
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11928 wxPyEndAllowThreads(__tstate);
11929 if (PyErr_Occurred()) SWIG_fail;
11930 }
11931 {
11932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11933 }
11934 return resultobj;
11935 fail:
11936 return NULL;
11937 }
11938
11939
11940 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11941 PyObject *resultobj = 0;
11942 wxGrid *arg1 = (wxGrid *) 0 ;
11943 bool result;
11944 void *argp1 = 0 ;
11945 int res1 = 0 ;
11946 PyObject *swig_obj[1] ;
11947
11948 if (!args) SWIG_fail;
11949 swig_obj[0] = args;
11950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11951 if (!SWIG_IsOK(res1)) {
11952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11953 }
11954 arg1 = reinterpret_cast< wxGrid * >(argp1);
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 {
11962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11963 }
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11971 PyObject *resultobj = 0;
11972 wxGrid *arg1 = (wxGrid *) 0 ;
11973 bool result;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 PyObject *swig_obj[1] ;
11977
11978 if (!args) SWIG_fail;
11979 swig_obj[0] = args;
11980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11981 if (!SWIG_IsOK(res1)) {
11982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11983 }
11984 arg1 = reinterpret_cast< wxGrid * >(argp1);
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 {
11992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11993 }
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *resultobj = 0;
12002 wxGrid *arg1 = (wxGrid *) 0 ;
12003 void *argp1 = 0 ;
12004 int res1 = 0 ;
12005 PyObject *swig_obj[1] ;
12006
12007 if (!args) SWIG_fail;
12008 swig_obj[0] = args;
12009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12010 if (!SWIG_IsOK(res1)) {
12011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12012 }
12013 arg1 = reinterpret_cast< wxGrid * >(argp1);
12014 {
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 (arg1)->ShowCellEditControl();
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 resultobj = SWIG_Py_Void();
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 PyObject *resultobj = 0;
12029 wxGrid *arg1 = (wxGrid *) 0 ;
12030 void *argp1 = 0 ;
12031 int res1 = 0 ;
12032 PyObject *swig_obj[1] ;
12033
12034 if (!args) SWIG_fail;
12035 swig_obj[0] = args;
12036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12037 if (!SWIG_IsOK(res1)) {
12038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12039 }
12040 arg1 = reinterpret_cast< wxGrid * >(argp1);
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 (arg1)->HideCellEditControl();
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 resultobj = SWIG_Py_Void();
12048 return resultobj;
12049 fail:
12050 return NULL;
12051 }
12052
12053
12054 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12055 PyObject *resultobj = 0;
12056 wxGrid *arg1 = (wxGrid *) 0 ;
12057 void *argp1 = 0 ;
12058 int res1 = 0 ;
12059 PyObject *swig_obj[1] ;
12060
12061 if (!args) SWIG_fail;
12062 swig_obj[0] = args;
12063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12064 if (!SWIG_IsOK(res1)) {
12065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12066 }
12067 arg1 = reinterpret_cast< wxGrid * >(argp1);
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 (arg1)->SaveEditControlValue();
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 resultobj = SWIG_Py_Void();
12075 return resultobj;
12076 fail:
12077 return NULL;
12078 }
12079
12080
12081 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12082 PyObject *resultobj = 0;
12083 wxGrid *arg1 = (wxGrid *) 0 ;
12084 int arg2 ;
12085 int arg3 ;
12086 wxGridCellCoords result;
12087 void *argp1 = 0 ;
12088 int res1 = 0 ;
12089 int val2 ;
12090 int ecode2 = 0 ;
12091 int val3 ;
12092 int ecode3 = 0 ;
12093 PyObject * obj0 = 0 ;
12094 PyObject * obj1 = 0 ;
12095 PyObject * obj2 = 0 ;
12096 char * kwnames[] = {
12097 (char *) "self",(char *) "x",(char *) "y", NULL
12098 };
12099
12100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12102 if (!SWIG_IsOK(res1)) {
12103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12104 }
12105 arg1 = reinterpret_cast< wxGrid * >(argp1);
12106 ecode2 = SWIG_AsVal_int(obj1, &val2);
12107 if (!SWIG_IsOK(ecode2)) {
12108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12109 }
12110 arg2 = static_cast< int >(val2);
12111 ecode3 = SWIG_AsVal_int(obj2, &val3);
12112 if (!SWIG_IsOK(ecode3)) {
12113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12114 }
12115 arg3 = static_cast< int >(val3);
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = wxGrid_XYToCell(arg1,arg2,arg3);
12119 wxPyEndAllowThreads(__tstate);
12120 if (PyErr_Occurred()) SWIG_fail;
12121 }
12122 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj = 0;
12131 wxGrid *arg1 = (wxGrid *) 0 ;
12132 int arg2 ;
12133 int result;
12134 void *argp1 = 0 ;
12135 int res1 = 0 ;
12136 int val2 ;
12137 int ecode2 = 0 ;
12138 PyObject * obj0 = 0 ;
12139 PyObject * obj1 = 0 ;
12140 char * kwnames[] = {
12141 (char *) "self",(char *) "y", NULL
12142 };
12143
12144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12146 if (!SWIG_IsOK(res1)) {
12147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12148 }
12149 arg1 = reinterpret_cast< wxGrid * >(argp1);
12150 ecode2 = SWIG_AsVal_int(obj1, &val2);
12151 if (!SWIG_IsOK(ecode2)) {
12152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12153 }
12154 arg2 = static_cast< int >(val2);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (int)(arg1)->YToRow(arg2);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_From_int(static_cast< int >(result));
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj = 0;
12170 wxGrid *arg1 = (wxGrid *) 0 ;
12171 int arg2 ;
12172 bool arg3 = (bool) false ;
12173 int result;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 int val2 ;
12177 int ecode2 = 0 ;
12178 bool val3 ;
12179 int ecode3 = 0 ;
12180 PyObject * obj0 = 0 ;
12181 PyObject * obj1 = 0 ;
12182 PyObject * obj2 = 0 ;
12183 char * kwnames[] = {
12184 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12185 };
12186
12187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12189 if (!SWIG_IsOK(res1)) {
12190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12191 }
12192 arg1 = reinterpret_cast< wxGrid * >(argp1);
12193 ecode2 = SWIG_AsVal_int(obj1, &val2);
12194 if (!SWIG_IsOK(ecode2)) {
12195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12196 }
12197 arg2 = static_cast< int >(val2);
12198 if (obj2) {
12199 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12200 if (!SWIG_IsOK(ecode3)) {
12201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12202 }
12203 arg3 = static_cast< bool >(val3);
12204 }
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 result = (int)(arg1)->XToCol(arg2,arg3);
12208 wxPyEndAllowThreads(__tstate);
12209 if (PyErr_Occurred()) SWIG_fail;
12210 }
12211 resultobj = SWIG_From_int(static_cast< int >(result));
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj = 0;
12220 wxGrid *arg1 = (wxGrid *) 0 ;
12221 int arg2 ;
12222 int result;
12223 void *argp1 = 0 ;
12224 int res1 = 0 ;
12225 int val2 ;
12226 int ecode2 = 0 ;
12227 PyObject * obj0 = 0 ;
12228 PyObject * obj1 = 0 ;
12229 char * kwnames[] = {
12230 (char *) "self",(char *) "y", NULL
12231 };
12232
12233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12235 if (!SWIG_IsOK(res1)) {
12236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12237 }
12238 arg1 = reinterpret_cast< wxGrid * >(argp1);
12239 ecode2 = SWIG_AsVal_int(obj1, &val2);
12240 if (!SWIG_IsOK(ecode2)) {
12241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12242 }
12243 arg2 = static_cast< int >(val2);
12244 {
12245 PyThreadState* __tstate = wxPyBeginAllowThreads();
12246 result = (int)(arg1)->YToEdgeOfRow(arg2);
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 resultobj = SWIG_From_int(static_cast< int >(result));
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj = 0;
12259 wxGrid *arg1 = (wxGrid *) 0 ;
12260 int arg2 ;
12261 int result;
12262 void *argp1 = 0 ;
12263 int res1 = 0 ;
12264 int val2 ;
12265 int ecode2 = 0 ;
12266 PyObject * obj0 = 0 ;
12267 PyObject * obj1 = 0 ;
12268 char * kwnames[] = {
12269 (char *) "self",(char *) "x", NULL
12270 };
12271
12272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12274 if (!SWIG_IsOK(res1)) {
12275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12276 }
12277 arg1 = reinterpret_cast< wxGrid * >(argp1);
12278 ecode2 = SWIG_AsVal_int(obj1, &val2);
12279 if (!SWIG_IsOK(ecode2)) {
12280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12281 }
12282 arg2 = static_cast< int >(val2);
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (int)(arg1)->XToEdgeOfCol(arg2);
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 resultobj = SWIG_From_int(static_cast< int >(result));
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj = 0;
12298 wxGrid *arg1 = (wxGrid *) 0 ;
12299 int arg2 ;
12300 int arg3 ;
12301 wxRect result;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 int val2 ;
12305 int ecode2 = 0 ;
12306 int val3 ;
12307 int ecode3 = 0 ;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 PyObject * obj2 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "self",(char *) "row",(char *) "col", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12319 }
12320 arg1 = reinterpret_cast< wxGrid * >(argp1);
12321 ecode2 = SWIG_AsVal_int(obj1, &val2);
12322 if (!SWIG_IsOK(ecode2)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12324 }
12325 arg2 = static_cast< int >(val2);
12326 ecode3 = SWIG_AsVal_int(obj2, &val3);
12327 if (!SWIG_IsOK(ecode3)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12329 }
12330 arg3 = static_cast< int >(val3);
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 result = (arg1)->CellToRect(arg2,arg3);
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12345 PyObject *resultobj = 0;
12346 wxGrid *arg1 = (wxGrid *) 0 ;
12347 int result;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 PyObject *swig_obj[1] ;
12351
12352 if (!args) SWIG_fail;
12353 swig_obj[0] = args;
12354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12355 if (!SWIG_IsOK(res1)) {
12356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12357 }
12358 arg1 = reinterpret_cast< wxGrid * >(argp1);
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 result = (int)(arg1)->GetGridCursorRow();
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 resultobj = SWIG_From_int(static_cast< int >(result));
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12373 PyObject *resultobj = 0;
12374 wxGrid *arg1 = (wxGrid *) 0 ;
12375 int result;
12376 void *argp1 = 0 ;
12377 int res1 = 0 ;
12378 PyObject *swig_obj[1] ;
12379
12380 if (!args) SWIG_fail;
12381 swig_obj[0] = args;
12382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12385 }
12386 arg1 = reinterpret_cast< wxGrid * >(argp1);
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 result = (int)(arg1)->GetGridCursorCol();
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 resultobj = SWIG_From_int(static_cast< int >(result));
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12401 PyObject *resultobj = 0;
12402 wxGrid *arg1 = (wxGrid *) 0 ;
12403 int arg2 ;
12404 int arg3 ;
12405 bool arg4 = (bool) true ;
12406 bool result;
12407 void *argp1 = 0 ;
12408 int res1 = 0 ;
12409 int val2 ;
12410 int ecode2 = 0 ;
12411 int val3 ;
12412 int ecode3 = 0 ;
12413 bool val4 ;
12414 int ecode4 = 0 ;
12415 PyObject * obj0 = 0 ;
12416 PyObject * obj1 = 0 ;
12417 PyObject * obj2 = 0 ;
12418 PyObject * obj3 = 0 ;
12419 char * kwnames[] = {
12420 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12421 };
12422
12423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12425 if (!SWIG_IsOK(res1)) {
12426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12427 }
12428 arg1 = reinterpret_cast< wxGrid * >(argp1);
12429 ecode2 = SWIG_AsVal_int(obj1, &val2);
12430 if (!SWIG_IsOK(ecode2)) {
12431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12432 }
12433 arg2 = static_cast< int >(val2);
12434 ecode3 = SWIG_AsVal_int(obj2, &val3);
12435 if (!SWIG_IsOK(ecode3)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12437 }
12438 arg3 = static_cast< int >(val3);
12439 if (obj3) {
12440 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12441 if (!SWIG_IsOK(ecode4)) {
12442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12443 }
12444 arg4 = static_cast< bool >(val4);
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12454 }
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12462 PyObject *resultobj = 0;
12463 wxGrid *arg1 = (wxGrid *) 0 ;
12464 int arg2 ;
12465 int arg3 ;
12466 void *argp1 = 0 ;
12467 int res1 = 0 ;
12468 int val2 ;
12469 int ecode2 = 0 ;
12470 int val3 ;
12471 int ecode3 = 0 ;
12472 PyObject * obj0 = 0 ;
12473 PyObject * obj1 = 0 ;
12474 PyObject * obj2 = 0 ;
12475 char * kwnames[] = {
12476 (char *) "self",(char *) "row",(char *) "col", NULL
12477 };
12478
12479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) 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_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12483 }
12484 arg1 = reinterpret_cast< wxGrid * >(argp1);
12485 ecode2 = SWIG_AsVal_int(obj1, &val2);
12486 if (!SWIG_IsOK(ecode2)) {
12487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12488 }
12489 arg2 = static_cast< int >(val2);
12490 ecode3 = SWIG_AsVal_int(obj2, &val3);
12491 if (!SWIG_IsOK(ecode3)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12493 }
12494 arg3 = static_cast< int >(val3);
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 (arg1)->MakeCellVisible(arg2,arg3);
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_Py_Void();
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj = 0;
12510 wxGrid *arg1 = (wxGrid *) 0 ;
12511 int arg2 ;
12512 int arg3 ;
12513 void *argp1 = 0 ;
12514 int res1 = 0 ;
12515 int val2 ;
12516 int ecode2 = 0 ;
12517 int val3 ;
12518 int ecode3 = 0 ;
12519 PyObject * obj0 = 0 ;
12520 PyObject * obj1 = 0 ;
12521 PyObject * obj2 = 0 ;
12522 char * kwnames[] = {
12523 (char *) "self",(char *) "row",(char *) "col", NULL
12524 };
12525
12526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12528 if (!SWIG_IsOK(res1)) {
12529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12530 }
12531 arg1 = reinterpret_cast< wxGrid * >(argp1);
12532 ecode2 = SWIG_AsVal_int(obj1, &val2);
12533 if (!SWIG_IsOK(ecode2)) {
12534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12535 }
12536 arg2 = static_cast< int >(val2);
12537 ecode3 = SWIG_AsVal_int(obj2, &val3);
12538 if (!SWIG_IsOK(ecode3)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12540 }
12541 arg3 = static_cast< int >(val3);
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 (arg1)->SetGridCursor(arg2,arg3);
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 resultobj = SWIG_Py_Void();
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj = 0;
12557 wxGrid *arg1 = (wxGrid *) 0 ;
12558 bool arg2 ;
12559 bool result;
12560 void *argp1 = 0 ;
12561 int res1 = 0 ;
12562 bool val2 ;
12563 int ecode2 = 0 ;
12564 PyObject * obj0 = 0 ;
12565 PyObject * obj1 = 0 ;
12566 char * kwnames[] = {
12567 (char *) "self",(char *) "expandSelection", NULL
12568 };
12569
12570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12572 if (!SWIG_IsOK(res1)) {
12573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12574 }
12575 arg1 = reinterpret_cast< wxGrid * >(argp1);
12576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12577 if (!SWIG_IsOK(ecode2)) {
12578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12579 }
12580 arg2 = static_cast< bool >(val2);
12581 {
12582 PyThreadState* __tstate = wxPyBeginAllowThreads();
12583 result = (bool)(arg1)->MoveCursorUp(arg2);
12584 wxPyEndAllowThreads(__tstate);
12585 if (PyErr_Occurred()) SWIG_fail;
12586 }
12587 {
12588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12589 }
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = 0;
12598 wxGrid *arg1 = (wxGrid *) 0 ;
12599 bool arg2 ;
12600 bool result;
12601 void *argp1 = 0 ;
12602 int res1 = 0 ;
12603 bool val2 ;
12604 int ecode2 = 0 ;
12605 PyObject * obj0 = 0 ;
12606 PyObject * obj1 = 0 ;
12607 char * kwnames[] = {
12608 (char *) "self",(char *) "expandSelection", NULL
12609 };
12610
12611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12613 if (!SWIG_IsOK(res1)) {
12614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12615 }
12616 arg1 = reinterpret_cast< wxGrid * >(argp1);
12617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12618 if (!SWIG_IsOK(ecode2)) {
12619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12620 }
12621 arg2 = static_cast< bool >(val2);
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 result = (bool)(arg1)->MoveCursorDown(arg2);
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12630 }
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj = 0;
12639 wxGrid *arg1 = (wxGrid *) 0 ;
12640 bool arg2 ;
12641 bool result;
12642 void *argp1 = 0 ;
12643 int res1 = 0 ;
12644 bool val2 ;
12645 int ecode2 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 char * kwnames[] = {
12649 (char *) "self",(char *) "expandSelection", NULL
12650 };
12651
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12656 }
12657 arg1 = reinterpret_cast< wxGrid * >(argp1);
12658 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12661 }
12662 arg2 = static_cast< bool >(val2);
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (bool)(arg1)->MoveCursorLeft(arg2);
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 {
12670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12671 }
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj = 0;
12680 wxGrid *arg1 = (wxGrid *) 0 ;
12681 bool arg2 ;
12682 bool result;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 bool val2 ;
12686 int ecode2 = 0 ;
12687 PyObject * obj0 = 0 ;
12688 PyObject * obj1 = 0 ;
12689 char * kwnames[] = {
12690 (char *) "self",(char *) "expandSelection", NULL
12691 };
12692
12693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12697 }
12698 arg1 = reinterpret_cast< wxGrid * >(argp1);
12699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12702 }
12703 arg2 = static_cast< bool >(val2);
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 result = (bool)(arg1)->MoveCursorRight(arg2);
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 {
12711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12712 }
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 PyObject *resultobj = 0;
12721 wxGrid *arg1 = (wxGrid *) 0 ;
12722 bool result;
12723 void *argp1 = 0 ;
12724 int res1 = 0 ;
12725 PyObject *swig_obj[1] ;
12726
12727 if (!args) SWIG_fail;
12728 swig_obj[0] = args;
12729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12730 if (!SWIG_IsOK(res1)) {
12731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12732 }
12733 arg1 = reinterpret_cast< wxGrid * >(argp1);
12734 {
12735 PyThreadState* __tstate = wxPyBeginAllowThreads();
12736 result = (bool)(arg1)->MovePageDown();
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12742 }
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *resultobj = 0;
12751 wxGrid *arg1 = (wxGrid *) 0 ;
12752 bool result;
12753 void *argp1 = 0 ;
12754 int res1 = 0 ;
12755 PyObject *swig_obj[1] ;
12756
12757 if (!args) SWIG_fail;
12758 swig_obj[0] = args;
12759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12762 }
12763 arg1 = reinterpret_cast< wxGrid * >(argp1);
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (bool)(arg1)->MovePageUp();
12767 wxPyEndAllowThreads(__tstate);
12768 if (PyErr_Occurred()) SWIG_fail;
12769 }
12770 {
12771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12772 }
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj = 0;
12781 wxGrid *arg1 = (wxGrid *) 0 ;
12782 bool arg2 ;
12783 bool result;
12784 void *argp1 = 0 ;
12785 int res1 = 0 ;
12786 bool val2 ;
12787 int ecode2 = 0 ;
12788 PyObject * obj0 = 0 ;
12789 PyObject * obj1 = 0 ;
12790 char * kwnames[] = {
12791 (char *) "self",(char *) "expandSelection", NULL
12792 };
12793
12794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12796 if (!SWIG_IsOK(res1)) {
12797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12798 }
12799 arg1 = reinterpret_cast< wxGrid * >(argp1);
12800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12801 if (!SWIG_IsOK(ecode2)) {
12802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12803 }
12804 arg2 = static_cast< bool >(val2);
12805 {
12806 PyThreadState* __tstate = wxPyBeginAllowThreads();
12807 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12808 wxPyEndAllowThreads(__tstate);
12809 if (PyErr_Occurred()) SWIG_fail;
12810 }
12811 {
12812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12813 }
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12821 PyObject *resultobj = 0;
12822 wxGrid *arg1 = (wxGrid *) 0 ;
12823 bool arg2 ;
12824 bool result;
12825 void *argp1 = 0 ;
12826 int res1 = 0 ;
12827 bool val2 ;
12828 int ecode2 = 0 ;
12829 PyObject * obj0 = 0 ;
12830 PyObject * obj1 = 0 ;
12831 char * kwnames[] = {
12832 (char *) "self",(char *) "expandSelection", NULL
12833 };
12834
12835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12837 if (!SWIG_IsOK(res1)) {
12838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12839 }
12840 arg1 = reinterpret_cast< wxGrid * >(argp1);
12841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12842 if (!SWIG_IsOK(ecode2)) {
12843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12844 }
12845 arg2 = static_cast< bool >(val2);
12846 {
12847 PyThreadState* __tstate = wxPyBeginAllowThreads();
12848 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 {
12853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12854 }
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj = 0;
12863 wxGrid *arg1 = (wxGrid *) 0 ;
12864 bool arg2 ;
12865 bool result;
12866 void *argp1 = 0 ;
12867 int res1 = 0 ;
12868 bool val2 ;
12869 int ecode2 = 0 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 char * kwnames[] = {
12873 (char *) "self",(char *) "expandSelection", NULL
12874 };
12875
12876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12878 if (!SWIG_IsOK(res1)) {
12879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12880 }
12881 arg1 = reinterpret_cast< wxGrid * >(argp1);
12882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12883 if (!SWIG_IsOK(ecode2)) {
12884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12885 }
12886 arg2 = static_cast< bool >(val2);
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 {
12894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12895 }
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12903 PyObject *resultobj = 0;
12904 wxGrid *arg1 = (wxGrid *) 0 ;
12905 bool arg2 ;
12906 bool result;
12907 void *argp1 = 0 ;
12908 int res1 = 0 ;
12909 bool val2 ;
12910 int ecode2 = 0 ;
12911 PyObject * obj0 = 0 ;
12912 PyObject * obj1 = 0 ;
12913 char * kwnames[] = {
12914 (char *) "self",(char *) "expandSelection", NULL
12915 };
12916
12917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12919 if (!SWIG_IsOK(res1)) {
12920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12921 }
12922 arg1 = reinterpret_cast< wxGrid * >(argp1);
12923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12924 if (!SWIG_IsOK(ecode2)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12926 }
12927 arg2 = static_cast< bool >(val2);
12928 {
12929 PyThreadState* __tstate = wxPyBeginAllowThreads();
12930 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 {
12935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12936 }
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12944 PyObject *resultobj = 0;
12945 wxGrid *arg1 = (wxGrid *) 0 ;
12946 int result;
12947 void *argp1 = 0 ;
12948 int res1 = 0 ;
12949 PyObject *swig_obj[1] ;
12950
12951 if (!args) SWIG_fail;
12952 swig_obj[0] = args;
12953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12954 if (!SWIG_IsOK(res1)) {
12955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12956 }
12957 arg1 = reinterpret_cast< wxGrid * >(argp1);
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (int)(arg1)->GetDefaultRowLabelSize();
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 resultobj = SWIG_From_int(static_cast< int >(result));
12965 return resultobj;
12966 fail:
12967 return NULL;
12968 }
12969
12970
12971 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12972 PyObject *resultobj = 0;
12973 wxGrid *arg1 = (wxGrid *) 0 ;
12974 int result;
12975 void *argp1 = 0 ;
12976 int res1 = 0 ;
12977 PyObject *swig_obj[1] ;
12978
12979 if (!args) SWIG_fail;
12980 swig_obj[0] = args;
12981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12982 if (!SWIG_IsOK(res1)) {
12983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12984 }
12985 arg1 = reinterpret_cast< wxGrid * >(argp1);
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (int)(arg1)->GetRowLabelSize();
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 resultobj = SWIG_From_int(static_cast< int >(result));
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 PyObject *resultobj = 0;
13001 wxGrid *arg1 = (wxGrid *) 0 ;
13002 int result;
13003 void *argp1 = 0 ;
13004 int res1 = 0 ;
13005 PyObject *swig_obj[1] ;
13006
13007 if (!args) SWIG_fail;
13008 swig_obj[0] = args;
13009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13010 if (!SWIG_IsOK(res1)) {
13011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13012 }
13013 arg1 = reinterpret_cast< wxGrid * >(argp1);
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = (int)(arg1)->GetDefaultColLabelSize();
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 resultobj = SWIG_From_int(static_cast< int >(result));
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13028 PyObject *resultobj = 0;
13029 wxGrid *arg1 = (wxGrid *) 0 ;
13030 int result;
13031 void *argp1 = 0 ;
13032 int res1 = 0 ;
13033 PyObject *swig_obj[1] ;
13034
13035 if (!args) SWIG_fail;
13036 swig_obj[0] = args;
13037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13038 if (!SWIG_IsOK(res1)) {
13039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13040 }
13041 arg1 = reinterpret_cast< wxGrid * >(argp1);
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 result = (int)(arg1)->GetColLabelSize();
13045 wxPyEndAllowThreads(__tstate);
13046 if (PyErr_Occurred()) SWIG_fail;
13047 }
13048 resultobj = SWIG_From_int(static_cast< int >(result));
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13056 PyObject *resultobj = 0;
13057 wxGrid *arg1 = (wxGrid *) 0 ;
13058 wxColour result;
13059 void *argp1 = 0 ;
13060 int res1 = 0 ;
13061 PyObject *swig_obj[1] ;
13062
13063 if (!args) SWIG_fail;
13064 swig_obj[0] = args;
13065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13066 if (!SWIG_IsOK(res1)) {
13067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13068 }
13069 arg1 = reinterpret_cast< wxGrid * >(argp1);
13070 {
13071 PyThreadState* __tstate = wxPyBeginAllowThreads();
13072 result = (arg1)->GetLabelBackgroundColour();
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxGrid *arg1 = (wxGrid *) 0 ;
13086 wxColour result;
13087 void *argp1 = 0 ;
13088 int res1 = 0 ;
13089 PyObject *swig_obj[1] ;
13090
13091 if (!args) SWIG_fail;
13092 swig_obj[0] = args;
13093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13096 }
13097 arg1 = reinterpret_cast< wxGrid * >(argp1);
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 result = (arg1)->GetLabelTextColour();
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13112 PyObject *resultobj = 0;
13113 wxGrid *arg1 = (wxGrid *) 0 ;
13114 wxFont result;
13115 void *argp1 = 0 ;
13116 int res1 = 0 ;
13117 PyObject *swig_obj[1] ;
13118
13119 if (!args) SWIG_fail;
13120 swig_obj[0] = args;
13121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13122 if (!SWIG_IsOK(res1)) {
13123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13124 }
13125 arg1 = reinterpret_cast< wxGrid * >(argp1);
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = (arg1)->GetLabelFont();
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13140 PyObject *resultobj = 0;
13141 wxGrid *arg1 = (wxGrid *) 0 ;
13142 int *arg2 = (int *) 0 ;
13143 int *arg3 = (int *) 0 ;
13144 void *argp1 = 0 ;
13145 int res1 = 0 ;
13146 int temp2 ;
13147 int res2 = SWIG_TMPOBJ ;
13148 int temp3 ;
13149 int res3 = SWIG_TMPOBJ ;
13150 PyObject *swig_obj[1] ;
13151
13152 arg2 = &temp2;
13153 arg3 = &temp3;
13154 if (!args) SWIG_fail;
13155 swig_obj[0] = args;
13156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13157 if (!SWIG_IsOK(res1)) {
13158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13159 }
13160 arg1 = reinterpret_cast< wxGrid * >(argp1);
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 (arg1)->GetRowLabelAlignment(arg2,arg3);
13164 wxPyEndAllowThreads(__tstate);
13165 if (PyErr_Occurred()) SWIG_fail;
13166 }
13167 resultobj = SWIG_Py_Void();
13168 if (SWIG_IsTmpObj(res2)) {
13169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13170 } else {
13171 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13173 }
13174 if (SWIG_IsTmpObj(res3)) {
13175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13176 } else {
13177 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13187 PyObject *resultobj = 0;
13188 wxGrid *arg1 = (wxGrid *) 0 ;
13189 int *arg2 = (int *) 0 ;
13190 int *arg3 = (int *) 0 ;
13191 void *argp1 = 0 ;
13192 int res1 = 0 ;
13193 int temp2 ;
13194 int res2 = SWIG_TMPOBJ ;
13195 int temp3 ;
13196 int res3 = SWIG_TMPOBJ ;
13197 PyObject *swig_obj[1] ;
13198
13199 arg2 = &temp2;
13200 arg3 = &temp3;
13201 if (!args) SWIG_fail;
13202 swig_obj[0] = args;
13203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13204 if (!SWIG_IsOK(res1)) {
13205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13206 }
13207 arg1 = reinterpret_cast< wxGrid * >(argp1);
13208 {
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 (arg1)->GetColLabelAlignment(arg2,arg3);
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 resultobj = SWIG_Py_Void();
13215 if (SWIG_IsTmpObj(res2)) {
13216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13217 } else {
13218 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13220 }
13221 if (SWIG_IsTmpObj(res3)) {
13222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13223 } else {
13224 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13226 }
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234 PyObject *resultobj = 0;
13235 wxGrid *arg1 = (wxGrid *) 0 ;
13236 int result;
13237 void *argp1 = 0 ;
13238 int res1 = 0 ;
13239 PyObject *swig_obj[1] ;
13240
13241 if (!args) SWIG_fail;
13242 swig_obj[0] = args;
13243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13244 if (!SWIG_IsOK(res1)) {
13245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13246 }
13247 arg1 = reinterpret_cast< wxGrid * >(argp1);
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 result = (int)(arg1)->GetColLabelTextOrientation();
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_From_int(static_cast< int >(result));
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj = 0;
13263 wxGrid *arg1 = (wxGrid *) 0 ;
13264 int arg2 ;
13265 wxString result;
13266 void *argp1 = 0 ;
13267 int res1 = 0 ;
13268 int val2 ;
13269 int ecode2 = 0 ;
13270 PyObject * obj0 = 0 ;
13271 PyObject * obj1 = 0 ;
13272 char * kwnames[] = {
13273 (char *) "self",(char *) "row", NULL
13274 };
13275
13276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13278 if (!SWIG_IsOK(res1)) {
13279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13280 }
13281 arg1 = reinterpret_cast< wxGrid * >(argp1);
13282 ecode2 = SWIG_AsVal_int(obj1, &val2);
13283 if (!SWIG_IsOK(ecode2)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13285 }
13286 arg2 = static_cast< int >(val2);
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (arg1)->GetRowLabelValue(arg2);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 #if wxUSE_UNICODE
13295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13296 #else
13297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13298 #endif
13299 }
13300 return resultobj;
13301 fail:
13302 return NULL;
13303 }
13304
13305
13306 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13307 PyObject *resultobj = 0;
13308 wxGrid *arg1 = (wxGrid *) 0 ;
13309 int arg2 ;
13310 wxString result;
13311 void *argp1 = 0 ;
13312 int res1 = 0 ;
13313 int val2 ;
13314 int ecode2 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "self",(char *) "col", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13325 }
13326 arg1 = reinterpret_cast< wxGrid * >(argp1);
13327 ecode2 = SWIG_AsVal_int(obj1, &val2);
13328 if (!SWIG_IsOK(ecode2)) {
13329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13330 }
13331 arg2 = static_cast< int >(val2);
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (arg1)->GetColLabelValue(arg2);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 {
13339 #if wxUSE_UNICODE
13340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13341 #else
13342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13343 #endif
13344 }
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352 PyObject *resultobj = 0;
13353 wxGrid *arg1 = (wxGrid *) 0 ;
13354 wxColour result;
13355 void *argp1 = 0 ;
13356 int res1 = 0 ;
13357 PyObject *swig_obj[1] ;
13358
13359 if (!args) SWIG_fail;
13360 swig_obj[0] = args;
13361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13362 if (!SWIG_IsOK(res1)) {
13363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13364 }
13365 arg1 = reinterpret_cast< wxGrid * >(argp1);
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 result = (arg1)->GetGridLineColour();
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *resultobj = 0;
13381 wxGrid *arg1 = (wxGrid *) 0 ;
13382 wxPen result;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 PyObject *swig_obj[1] ;
13386
13387 if (!args) SWIG_fail;
13388 swig_obj[0] = args;
13389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13390 if (!SWIG_IsOK(res1)) {
13391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13392 }
13393 arg1 = reinterpret_cast< wxGrid * >(argp1);
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 result = (arg1)->GetDefaultGridLinePen();
13397 wxPyEndAllowThreads(__tstate);
13398 if (PyErr_Occurred()) SWIG_fail;
13399 }
13400 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj = 0;
13409 wxGrid *arg1 = (wxGrid *) 0 ;
13410 int arg2 ;
13411 wxPen result;
13412 void *argp1 = 0 ;
13413 int res1 = 0 ;
13414 int val2 ;
13415 int ecode2 = 0 ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "self",(char *) "row", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13424 if (!SWIG_IsOK(res1)) {
13425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13426 }
13427 arg1 = reinterpret_cast< wxGrid * >(argp1);
13428 ecode2 = SWIG_AsVal_int(obj1, &val2);
13429 if (!SWIG_IsOK(ecode2)) {
13430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13431 }
13432 arg2 = static_cast< int >(val2);
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 result = (arg1)->GetRowGridLinePen(arg2);
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13440 return resultobj;
13441 fail:
13442 return NULL;
13443 }
13444
13445
13446 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13447 PyObject *resultobj = 0;
13448 wxGrid *arg1 = (wxGrid *) 0 ;
13449 int arg2 ;
13450 wxPen result;
13451 void *argp1 = 0 ;
13452 int res1 = 0 ;
13453 int val2 ;
13454 int ecode2 = 0 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 char * kwnames[] = {
13458 (char *) "self",(char *) "col", NULL
13459 };
13460
13461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13465 }
13466 arg1 = reinterpret_cast< wxGrid * >(argp1);
13467 ecode2 = SWIG_AsVal_int(obj1, &val2);
13468 if (!SWIG_IsOK(ecode2)) {
13469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13470 }
13471 arg2 = static_cast< int >(val2);
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (arg1)->GetColGridLinePen(arg2);
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486 PyObject *resultobj = 0;
13487 wxGrid *arg1 = (wxGrid *) 0 ;
13488 wxColour result;
13489 void *argp1 = 0 ;
13490 int res1 = 0 ;
13491 PyObject *swig_obj[1] ;
13492
13493 if (!args) SWIG_fail;
13494 swig_obj[0] = args;
13495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13496 if (!SWIG_IsOK(res1)) {
13497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13498 }
13499 arg1 = reinterpret_cast< wxGrid * >(argp1);
13500 {
13501 PyThreadState* __tstate = wxPyBeginAllowThreads();
13502 result = (arg1)->GetCellHighlightColour();
13503 wxPyEndAllowThreads(__tstate);
13504 if (PyErr_Occurred()) SWIG_fail;
13505 }
13506 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13514 PyObject *resultobj = 0;
13515 wxGrid *arg1 = (wxGrid *) 0 ;
13516 int result;
13517 void *argp1 = 0 ;
13518 int res1 = 0 ;
13519 PyObject *swig_obj[1] ;
13520
13521 if (!args) SWIG_fail;
13522 swig_obj[0] = args;
13523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13524 if (!SWIG_IsOK(res1)) {
13525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13526 }
13527 arg1 = reinterpret_cast< wxGrid * >(argp1);
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 result = (int)(arg1)->GetCellHighlightPenWidth();
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 resultobj = SWIG_From_int(static_cast< int >(result));
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13542 PyObject *resultobj = 0;
13543 wxGrid *arg1 = (wxGrid *) 0 ;
13544 int result;
13545 void *argp1 = 0 ;
13546 int res1 = 0 ;
13547 PyObject *swig_obj[1] ;
13548
13549 if (!args) SWIG_fail;
13550 swig_obj[0] = args;
13551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13552 if (!SWIG_IsOK(res1)) {
13553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13554 }
13555 arg1 = reinterpret_cast< wxGrid * >(argp1);
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 result = (int)(arg1)->GetCellHighlightROPenWidth();
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_From_int(static_cast< int >(result));
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = 0;
13571 wxGrid *arg1 = (wxGrid *) 0 ;
13572 int arg2 ;
13573 void *argp1 = 0 ;
13574 int res1 = 0 ;
13575 int val2 ;
13576 int ecode2 = 0 ;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 char * kwnames[] = {
13580 (char *) "self",(char *) "width", NULL
13581 };
13582
13583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13585 if (!SWIG_IsOK(res1)) {
13586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13587 }
13588 arg1 = reinterpret_cast< wxGrid * >(argp1);
13589 ecode2 = SWIG_AsVal_int(obj1, &val2);
13590 if (!SWIG_IsOK(ecode2)) {
13591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13592 }
13593 arg2 = static_cast< int >(val2);
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 (arg1)->SetRowLabelSize(arg2);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_Py_Void();
13601 return resultobj;
13602 fail:
13603 return NULL;
13604 }
13605
13606
13607 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13608 PyObject *resultobj = 0;
13609 wxGrid *arg1 = (wxGrid *) 0 ;
13610 int arg2 ;
13611 void *argp1 = 0 ;
13612 int res1 = 0 ;
13613 int val2 ;
13614 int ecode2 = 0 ;
13615 PyObject * obj0 = 0 ;
13616 PyObject * obj1 = 0 ;
13617 char * kwnames[] = {
13618 (char *) "self",(char *) "height", NULL
13619 };
13620
13621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13623 if (!SWIG_IsOK(res1)) {
13624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13625 }
13626 arg1 = reinterpret_cast< wxGrid * >(argp1);
13627 ecode2 = SWIG_AsVal_int(obj1, &val2);
13628 if (!SWIG_IsOK(ecode2)) {
13629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13630 }
13631 arg2 = static_cast< int >(val2);
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 (arg1)->SetColLabelSize(arg2);
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_Py_Void();
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = 0;
13647 wxGrid *arg1 = (wxGrid *) 0 ;
13648 wxColour *arg2 = 0 ;
13649 void *argp1 = 0 ;
13650 int res1 = 0 ;
13651 wxColour temp2 ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "self",(char *)"arg2", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13662 }
13663 arg1 = reinterpret_cast< wxGrid * >(argp1);
13664 {
13665 arg2 = &temp2;
13666 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13667 }
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_Py_Void();
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 wxGrid *arg1 = (wxGrid *) 0 ;
13684 wxColour *arg2 = 0 ;
13685 void *argp1 = 0 ;
13686 int res1 = 0 ;
13687 wxColour temp2 ;
13688 PyObject * obj0 = 0 ;
13689 PyObject * obj1 = 0 ;
13690 char * kwnames[] = {
13691 (char *) "self",(char *)"arg2", NULL
13692 };
13693
13694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13696 if (!SWIG_IsOK(res1)) {
13697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13698 }
13699 arg1 = reinterpret_cast< wxGrid * >(argp1);
13700 {
13701 arg2 = &temp2;
13702 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 resultobj = SWIG_Py_Void();
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13718 PyObject *resultobj = 0;
13719 wxGrid *arg1 = (wxGrid *) 0 ;
13720 wxFont *arg2 = 0 ;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 void *argp2 = 0 ;
13724 int res2 = 0 ;
13725 PyObject * obj0 = 0 ;
13726 PyObject * obj1 = 0 ;
13727 char * kwnames[] = {
13728 (char *) "self",(char *)"arg2", NULL
13729 };
13730
13731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13733 if (!SWIG_IsOK(res1)) {
13734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13735 }
13736 arg1 = reinterpret_cast< wxGrid * >(argp1);
13737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13738 if (!SWIG_IsOK(res2)) {
13739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13740 }
13741 if (!argp2) {
13742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13743 }
13744 arg2 = reinterpret_cast< wxFont * >(argp2);
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 (arg1)->SetLabelFont((wxFont const &)*arg2);
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 resultobj = SWIG_Py_Void();
13752 return resultobj;
13753 fail:
13754 return NULL;
13755 }
13756
13757
13758 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13759 PyObject *resultobj = 0;
13760 wxGrid *arg1 = (wxGrid *) 0 ;
13761 int arg2 ;
13762 int arg3 ;
13763 void *argp1 = 0 ;
13764 int res1 = 0 ;
13765 int val2 ;
13766 int ecode2 = 0 ;
13767 int val3 ;
13768 int ecode3 = 0 ;
13769 PyObject * obj0 = 0 ;
13770 PyObject * obj1 = 0 ;
13771 PyObject * obj2 = 0 ;
13772 char * kwnames[] = {
13773 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13774 };
13775
13776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13778 if (!SWIG_IsOK(res1)) {
13779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13780 }
13781 arg1 = reinterpret_cast< wxGrid * >(argp1);
13782 ecode2 = SWIG_AsVal_int(obj1, &val2);
13783 if (!SWIG_IsOK(ecode2)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13785 }
13786 arg2 = static_cast< int >(val2);
13787 ecode3 = SWIG_AsVal_int(obj2, &val3);
13788 if (!SWIG_IsOK(ecode3)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13790 }
13791 arg3 = static_cast< int >(val3);
13792 {
13793 PyThreadState* __tstate = wxPyBeginAllowThreads();
13794 (arg1)->SetRowLabelAlignment(arg2,arg3);
13795 wxPyEndAllowThreads(__tstate);
13796 if (PyErr_Occurred()) SWIG_fail;
13797 }
13798 resultobj = SWIG_Py_Void();
13799 return resultobj;
13800 fail:
13801 return NULL;
13802 }
13803
13804
13805 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj = 0;
13807 wxGrid *arg1 = (wxGrid *) 0 ;
13808 int arg2 ;
13809 int arg3 ;
13810 void *argp1 = 0 ;
13811 int res1 = 0 ;
13812 int val2 ;
13813 int ecode2 = 0 ;
13814 int val3 ;
13815 int ecode3 = 0 ;
13816 PyObject * obj0 = 0 ;
13817 PyObject * obj1 = 0 ;
13818 PyObject * obj2 = 0 ;
13819 char * kwnames[] = {
13820 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13821 };
13822
13823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13825 if (!SWIG_IsOK(res1)) {
13826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13827 }
13828 arg1 = reinterpret_cast< wxGrid * >(argp1);
13829 ecode2 = SWIG_AsVal_int(obj1, &val2);
13830 if (!SWIG_IsOK(ecode2)) {
13831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13832 }
13833 arg2 = static_cast< int >(val2);
13834 ecode3 = SWIG_AsVal_int(obj2, &val3);
13835 if (!SWIG_IsOK(ecode3)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13837 }
13838 arg3 = static_cast< int >(val3);
13839 {
13840 PyThreadState* __tstate = wxPyBeginAllowThreads();
13841 (arg1)->SetColLabelAlignment(arg2,arg3);
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 resultobj = SWIG_Py_Void();
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj = 0;
13854 wxGrid *arg1 = (wxGrid *) 0 ;
13855 int arg2 ;
13856 void *argp1 = 0 ;
13857 int res1 = 0 ;
13858 int val2 ;
13859 int ecode2 = 0 ;
13860 PyObject * obj0 = 0 ;
13861 PyObject * obj1 = 0 ;
13862 char * kwnames[] = {
13863 (char *) "self",(char *) "textOrientation", NULL
13864 };
13865
13866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13868 if (!SWIG_IsOK(res1)) {
13869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13870 }
13871 arg1 = reinterpret_cast< wxGrid * >(argp1);
13872 ecode2 = SWIG_AsVal_int(obj1, &val2);
13873 if (!SWIG_IsOK(ecode2)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13875 }
13876 arg2 = static_cast< int >(val2);
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 (arg1)->SetColLabelTextOrientation(arg2);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_Py_Void();
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxGrid *arg1 = (wxGrid *) 0 ;
13893 int arg2 ;
13894 wxString *arg3 = 0 ;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 bool temp3 = false ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "self",(char *) "row",(char *)"arg3", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13909 if (!SWIG_IsOK(res1)) {
13910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13911 }
13912 arg1 = reinterpret_cast< wxGrid * >(argp1);
13913 ecode2 = SWIG_AsVal_int(obj1, &val2);
13914 if (!SWIG_IsOK(ecode2)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13916 }
13917 arg2 = static_cast< int >(val2);
13918 {
13919 arg3 = wxString_in_helper(obj2);
13920 if (arg3 == NULL) SWIG_fail;
13921 temp3 = true;
13922 }
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 resultobj = SWIG_Py_Void();
13930 {
13931 if (temp3)
13932 delete arg3;
13933 }
13934 return resultobj;
13935 fail:
13936 {
13937 if (temp3)
13938 delete arg3;
13939 }
13940 return NULL;
13941 }
13942
13943
13944 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj = 0;
13946 wxGrid *arg1 = (wxGrid *) 0 ;
13947 int arg2 ;
13948 wxString *arg3 = 0 ;
13949 void *argp1 = 0 ;
13950 int res1 = 0 ;
13951 int val2 ;
13952 int ecode2 = 0 ;
13953 bool temp3 = false ;
13954 PyObject * obj0 = 0 ;
13955 PyObject * obj1 = 0 ;
13956 PyObject * obj2 = 0 ;
13957 char * kwnames[] = {
13958 (char *) "self",(char *) "col",(char *)"arg3", NULL
13959 };
13960
13961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13963 if (!SWIG_IsOK(res1)) {
13964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13965 }
13966 arg1 = reinterpret_cast< wxGrid * >(argp1);
13967 ecode2 = SWIG_AsVal_int(obj1, &val2);
13968 if (!SWIG_IsOK(ecode2)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13970 }
13971 arg2 = static_cast< int >(val2);
13972 {
13973 arg3 = wxString_in_helper(obj2);
13974 if (arg3 == NULL) SWIG_fail;
13975 temp3 = true;
13976 }
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_Py_Void();
13984 {
13985 if (temp3)
13986 delete arg3;
13987 }
13988 return resultobj;
13989 fail:
13990 {
13991 if (temp3)
13992 delete arg3;
13993 }
13994 return NULL;
13995 }
13996
13997
13998 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj = 0;
14000 wxGrid *arg1 = (wxGrid *) 0 ;
14001 wxColour *arg2 = 0 ;
14002 void *argp1 = 0 ;
14003 int res1 = 0 ;
14004 wxColour temp2 ;
14005 PyObject * obj0 = 0 ;
14006 PyObject * obj1 = 0 ;
14007 char * kwnames[] = {
14008 (char *) "self",(char *)"arg2", NULL
14009 };
14010
14011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14013 if (!SWIG_IsOK(res1)) {
14014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14015 }
14016 arg1 = reinterpret_cast< wxGrid * >(argp1);
14017 {
14018 arg2 = &temp2;
14019 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj = 0;
14036 wxGrid *arg1 = (wxGrid *) 0 ;
14037 wxColour *arg2 = 0 ;
14038 void *argp1 = 0 ;
14039 int res1 = 0 ;
14040 wxColour temp2 ;
14041 PyObject * obj0 = 0 ;
14042 PyObject * obj1 = 0 ;
14043 char * kwnames[] = {
14044 (char *) "self",(char *)"arg2", NULL
14045 };
14046
14047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14049 if (!SWIG_IsOK(res1)) {
14050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14051 }
14052 arg1 = reinterpret_cast< wxGrid * >(argp1);
14053 {
14054 arg2 = &temp2;
14055 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14056 }
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_Py_Void();
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj = 0;
14072 wxGrid *arg1 = (wxGrid *) 0 ;
14073 int arg2 ;
14074 void *argp1 = 0 ;
14075 int res1 = 0 ;
14076 int val2 ;
14077 int ecode2 = 0 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 char * kwnames[] = {
14081 (char *) "self",(char *) "width", NULL
14082 };
14083
14084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14086 if (!SWIG_IsOK(res1)) {
14087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14088 }
14089 arg1 = reinterpret_cast< wxGrid * >(argp1);
14090 ecode2 = SWIG_AsVal_int(obj1, &val2);
14091 if (!SWIG_IsOK(ecode2)) {
14092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14093 }
14094 arg2 = static_cast< int >(val2);
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 (arg1)->SetCellHighlightPenWidth(arg2);
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 resultobj = SWIG_Py_Void();
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14109 PyObject *resultobj = 0;
14110 wxGrid *arg1 = (wxGrid *) 0 ;
14111 int arg2 ;
14112 void *argp1 = 0 ;
14113 int res1 = 0 ;
14114 int val2 ;
14115 int ecode2 = 0 ;
14116 PyObject * obj0 = 0 ;
14117 PyObject * obj1 = 0 ;
14118 char * kwnames[] = {
14119 (char *) "self",(char *) "width", NULL
14120 };
14121
14122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14124 if (!SWIG_IsOK(res1)) {
14125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14126 }
14127 arg1 = reinterpret_cast< wxGrid * >(argp1);
14128 ecode2 = SWIG_AsVal_int(obj1, &val2);
14129 if (!SWIG_IsOK(ecode2)) {
14130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14131 }
14132 arg2 = static_cast< int >(val2);
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 (arg1)->SetCellHighlightROPenWidth(arg2);
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 resultobj = SWIG_Py_Void();
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj = 0;
14148 wxGrid *arg1 = (wxGrid *) 0 ;
14149 bool arg2 = (bool) true ;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 bool val2 ;
14153 int ecode2 = 0 ;
14154 PyObject * obj0 = 0 ;
14155 PyObject * obj1 = 0 ;
14156 char * kwnames[] = {
14157 (char *) "self",(char *) "enable", NULL
14158 };
14159
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14164 }
14165 arg1 = reinterpret_cast< wxGrid * >(argp1);
14166 if (obj1) {
14167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14168 if (!SWIG_IsOK(ecode2)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14170 }
14171 arg2 = static_cast< bool >(val2);
14172 }
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 (arg1)->EnableDragRowSize(arg2);
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 resultobj = SWIG_Py_Void();
14180 return resultobj;
14181 fail:
14182 return NULL;
14183 }
14184
14185
14186 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14187 PyObject *resultobj = 0;
14188 wxGrid *arg1 = (wxGrid *) 0 ;
14189 void *argp1 = 0 ;
14190 int res1 = 0 ;
14191 PyObject *swig_obj[1] ;
14192
14193 if (!args) SWIG_fail;
14194 swig_obj[0] = args;
14195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14196 if (!SWIG_IsOK(res1)) {
14197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14198 }
14199 arg1 = reinterpret_cast< wxGrid * >(argp1);
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 (arg1)->DisableDragRowSize();
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_Py_Void();
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14214 PyObject *resultobj = 0;
14215 wxGrid *arg1 = (wxGrid *) 0 ;
14216 bool result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 PyObject *swig_obj[1] ;
14220
14221 if (!args) SWIG_fail;
14222 swig_obj[0] = args;
14223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14226 }
14227 arg1 = reinterpret_cast< wxGrid * >(argp1);
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (bool)(arg1)->CanDragRowSize();
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 {
14235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 wxGrid *arg1 = (wxGrid *) 0 ;
14246 bool arg2 = (bool) true ;
14247 void *argp1 = 0 ;
14248 int res1 = 0 ;
14249 bool val2 ;
14250 int ecode2 = 0 ;
14251 PyObject * obj0 = 0 ;
14252 PyObject * obj1 = 0 ;
14253 char * kwnames[] = {
14254 (char *) "self",(char *) "enable", NULL
14255 };
14256
14257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14261 }
14262 arg1 = reinterpret_cast< wxGrid * >(argp1);
14263 if (obj1) {
14264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14265 if (!SWIG_IsOK(ecode2)) {
14266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14267 }
14268 arg2 = static_cast< bool >(val2);
14269 }
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 (arg1)->EnableDragColSize(arg2);
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 resultobj = SWIG_Py_Void();
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14284 PyObject *resultobj = 0;
14285 wxGrid *arg1 = (wxGrid *) 0 ;
14286 void *argp1 = 0 ;
14287 int res1 = 0 ;
14288 PyObject *swig_obj[1] ;
14289
14290 if (!args) SWIG_fail;
14291 swig_obj[0] = args;
14292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14293 if (!SWIG_IsOK(res1)) {
14294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14295 }
14296 arg1 = reinterpret_cast< wxGrid * >(argp1);
14297 {
14298 PyThreadState* __tstate = wxPyBeginAllowThreads();
14299 (arg1)->DisableDragColSize();
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 resultobj = SWIG_Py_Void();
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311 PyObject *resultobj = 0;
14312 wxGrid *arg1 = (wxGrid *) 0 ;
14313 bool result;
14314 void *argp1 = 0 ;
14315 int res1 = 0 ;
14316 PyObject *swig_obj[1] ;
14317
14318 if (!args) SWIG_fail;
14319 swig_obj[0] = args;
14320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14321 if (!SWIG_IsOK(res1)) {
14322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14323 }
14324 arg1 = reinterpret_cast< wxGrid * >(argp1);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (bool)(arg1)->CanDragColSize();
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 {
14332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14333 }
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxGrid *arg1 = (wxGrid *) 0 ;
14343 bool arg2 = (bool) true ;
14344 void *argp1 = 0 ;
14345 int res1 = 0 ;
14346 bool val2 ;
14347 int ecode2 = 0 ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "self",(char *) "enable", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14356 if (!SWIG_IsOK(res1)) {
14357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14358 }
14359 arg1 = reinterpret_cast< wxGrid * >(argp1);
14360 if (obj1) {
14361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14362 if (!SWIG_IsOK(ecode2)) {
14363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14364 }
14365 arg2 = static_cast< bool >(val2);
14366 }
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 (arg1)->EnableDragColMove(arg2);
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_Py_Void();
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14381 PyObject *resultobj = 0;
14382 wxGrid *arg1 = (wxGrid *) 0 ;
14383 void *argp1 = 0 ;
14384 int res1 = 0 ;
14385 PyObject *swig_obj[1] ;
14386
14387 if (!args) SWIG_fail;
14388 swig_obj[0] = args;
14389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14392 }
14393 arg1 = reinterpret_cast< wxGrid * >(argp1);
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 (arg1)->DisableDragColMove();
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = SWIG_Py_Void();
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14408 PyObject *resultobj = 0;
14409 wxGrid *arg1 = (wxGrid *) 0 ;
14410 bool result;
14411 void *argp1 = 0 ;
14412 int res1 = 0 ;
14413 PyObject *swig_obj[1] ;
14414
14415 if (!args) SWIG_fail;
14416 swig_obj[0] = args;
14417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14420 }
14421 arg1 = reinterpret_cast< wxGrid * >(argp1);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (bool)(arg1)->CanDragColMove();
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14430 }
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxGrid *arg1 = (wxGrid *) 0 ;
14440 bool arg2 = (bool) true ;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 bool val2 ;
14444 int ecode2 = 0 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "enable", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14455 }
14456 arg1 = reinterpret_cast< wxGrid * >(argp1);
14457 if (obj1) {
14458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14459 if (!SWIG_IsOK(ecode2)) {
14460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14461 }
14462 arg2 = static_cast< bool >(val2);
14463 }
14464 {
14465 PyThreadState* __tstate = wxPyBeginAllowThreads();
14466 (arg1)->EnableDragGridSize(arg2);
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 resultobj = SWIG_Py_Void();
14471 return resultobj;
14472 fail:
14473 return NULL;
14474 }
14475
14476
14477 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14478 PyObject *resultobj = 0;
14479 wxGrid *arg1 = (wxGrid *) 0 ;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 PyObject *swig_obj[1] ;
14483
14484 if (!args) SWIG_fail;
14485 swig_obj[0] = args;
14486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14487 if (!SWIG_IsOK(res1)) {
14488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14489 }
14490 arg1 = reinterpret_cast< wxGrid * >(argp1);
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->DisableDragGridSize();
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 resultobj = SWIG_Py_Void();
14498 return resultobj;
14499 fail:
14500 return NULL;
14501 }
14502
14503
14504 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14505 PyObject *resultobj = 0;
14506 wxGrid *arg1 = (wxGrid *) 0 ;
14507 bool result;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 PyObject *swig_obj[1] ;
14511
14512 if (!args) SWIG_fail;
14513 swig_obj[0] = args;
14514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14515 if (!SWIG_IsOK(res1)) {
14516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14517 }
14518 arg1 = reinterpret_cast< wxGrid * >(argp1);
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (bool)(arg1)->CanDragGridSize();
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj = 0;
14536 wxGrid *arg1 = (wxGrid *) 0 ;
14537 bool arg2 = (bool) true ;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 bool val2 ;
14541 int ecode2 = 0 ;
14542 PyObject * obj0 = 0 ;
14543 PyObject * obj1 = 0 ;
14544 char * kwnames[] = {
14545 (char *) "self",(char *) "enable", NULL
14546 };
14547
14548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14550 if (!SWIG_IsOK(res1)) {
14551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14552 }
14553 arg1 = reinterpret_cast< wxGrid * >(argp1);
14554 if (obj1) {
14555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14556 if (!SWIG_IsOK(ecode2)) {
14557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14558 }
14559 arg2 = static_cast< bool >(val2);
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->EnableDragCell(arg2);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = SWIG_Py_Void();
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14575 PyObject *resultobj = 0;
14576 wxGrid *arg1 = (wxGrid *) 0 ;
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_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14586 }
14587 arg1 = reinterpret_cast< wxGrid * >(argp1);
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 (arg1)->DisableDragCell();
14591 wxPyEndAllowThreads(__tstate);
14592 if (PyErr_Occurred()) SWIG_fail;
14593 }
14594 resultobj = SWIG_Py_Void();
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14602 PyObject *resultobj = 0;
14603 wxGrid *arg1 = (wxGrid *) 0 ;
14604 bool result;
14605 void *argp1 = 0 ;
14606 int res1 = 0 ;
14607 PyObject *swig_obj[1] ;
14608
14609 if (!args) SWIG_fail;
14610 swig_obj[0] = args;
14611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14612 if (!SWIG_IsOK(res1)) {
14613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14614 }
14615 arg1 = reinterpret_cast< wxGrid * >(argp1);
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (bool)(arg1)->CanDragCell();
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 {
14623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14624 }
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj = 0;
14633 wxGrid *arg1 = (wxGrid *) 0 ;
14634 int arg2 ;
14635 int arg3 ;
14636 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14637 void *argp1 = 0 ;
14638 int res1 = 0 ;
14639 int val2 ;
14640 int ecode2 = 0 ;
14641 int val3 ;
14642 int ecode3 = 0 ;
14643 void *argp4 = 0 ;
14644 int res4 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 PyObject * obj3 = 0 ;
14649 char * kwnames[] = {
14650 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14651 };
14652
14653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14655 if (!SWIG_IsOK(res1)) {
14656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14657 }
14658 arg1 = reinterpret_cast< wxGrid * >(argp1);
14659 ecode2 = SWIG_AsVal_int(obj1, &val2);
14660 if (!SWIG_IsOK(ecode2)) {
14661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14662 }
14663 arg2 = static_cast< int >(val2);
14664 ecode3 = SWIG_AsVal_int(obj2, &val3);
14665 if (!SWIG_IsOK(ecode3)) {
14666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14667 }
14668 arg3 = static_cast< int >(val3);
14669 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14670 if (!SWIG_IsOK(res4)) {
14671 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14672 }
14673 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 (arg1)->SetAttr(arg2,arg3,arg4);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 resultobj = SWIG_Py_Void();
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj = 0;
14689 wxGrid *arg1 = (wxGrid *) 0 ;
14690 int arg2 ;
14691 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14692 void *argp1 = 0 ;
14693 int res1 = 0 ;
14694 int val2 ;
14695 int ecode2 = 0 ;
14696 void *argp3 = 0 ;
14697 int res3 = 0 ;
14698 PyObject * obj0 = 0 ;
14699 PyObject * obj1 = 0 ;
14700 PyObject * obj2 = 0 ;
14701 char * kwnames[] = {
14702 (char *) "self",(char *) "row",(char *) "attr", NULL
14703 };
14704
14705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14707 if (!SWIG_IsOK(res1)) {
14708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14709 }
14710 arg1 = reinterpret_cast< wxGrid * >(argp1);
14711 ecode2 = SWIG_AsVal_int(obj1, &val2);
14712 if (!SWIG_IsOK(ecode2)) {
14713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14714 }
14715 arg2 = static_cast< int >(val2);
14716 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14717 if (!SWIG_IsOK(res3)) {
14718 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14719 }
14720 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 (arg1)->SetRowAttr(arg2,arg3);
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 resultobj = SWIG_Py_Void();
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj = 0;
14736 wxGrid *arg1 = (wxGrid *) 0 ;
14737 int arg2 ;
14738 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14739 void *argp1 = 0 ;
14740 int res1 = 0 ;
14741 int val2 ;
14742 int ecode2 = 0 ;
14743 void *argp3 = 0 ;
14744 int res3 = 0 ;
14745 PyObject * obj0 = 0 ;
14746 PyObject * obj1 = 0 ;
14747 PyObject * obj2 = 0 ;
14748 char * kwnames[] = {
14749 (char *) "self",(char *) "col",(char *) "attr", NULL
14750 };
14751
14752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14754 if (!SWIG_IsOK(res1)) {
14755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14756 }
14757 arg1 = reinterpret_cast< wxGrid * >(argp1);
14758 ecode2 = SWIG_AsVal_int(obj1, &val2);
14759 if (!SWIG_IsOK(ecode2)) {
14760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14761 }
14762 arg2 = static_cast< int >(val2);
14763 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14764 if (!SWIG_IsOK(res3)) {
14765 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14766 }
14767 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14768 {
14769 PyThreadState* __tstate = wxPyBeginAllowThreads();
14770 (arg1)->SetColAttr(arg2,arg3);
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 resultobj = SWIG_Py_Void();
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14782 PyObject *resultobj = 0;
14783 wxGrid *arg1 = (wxGrid *) 0 ;
14784 int arg2 ;
14785 int arg3 ;
14786 wxGridCellAttr *result = 0 ;
14787 void *argp1 = 0 ;
14788 int res1 = 0 ;
14789 int val2 ;
14790 int ecode2 = 0 ;
14791 int val3 ;
14792 int ecode3 = 0 ;
14793 PyObject * obj0 = 0 ;
14794 PyObject * obj1 = 0 ;
14795 PyObject * obj2 = 0 ;
14796 char * kwnames[] = {
14797 (char *) "self",(char *) "row",(char *) "col", NULL
14798 };
14799
14800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14802 if (!SWIG_IsOK(res1)) {
14803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14804 }
14805 arg1 = reinterpret_cast< wxGrid * >(argp1);
14806 ecode2 = SWIG_AsVal_int(obj1, &val2);
14807 if (!SWIG_IsOK(ecode2)) {
14808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14809 }
14810 arg2 = static_cast< int >(val2);
14811 ecode3 = SWIG_AsVal_int(obj2, &val3);
14812 if (!SWIG_IsOK(ecode3)) {
14813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14814 }
14815 arg3 = static_cast< int >(val3);
14816 {
14817 PyThreadState* __tstate = wxPyBeginAllowThreads();
14818 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14819 wxPyEndAllowThreads(__tstate);
14820 if (PyErr_Occurred()) SWIG_fail;
14821 }
14822 {
14823 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14824 }
14825 return resultobj;
14826 fail:
14827 return NULL;
14828 }
14829
14830
14831 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14832 PyObject *resultobj = 0;
14833 wxGrid *arg1 = (wxGrid *) 0 ;
14834 int arg2 ;
14835 void *argp1 = 0 ;
14836 int res1 = 0 ;
14837 int val2 ;
14838 int ecode2 = 0 ;
14839 PyObject * obj0 = 0 ;
14840 PyObject * obj1 = 0 ;
14841 char * kwnames[] = {
14842 (char *) "self",(char *) "col", NULL
14843 };
14844
14845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14849 }
14850 arg1 = reinterpret_cast< wxGrid * >(argp1);
14851 ecode2 = SWIG_AsVal_int(obj1, &val2);
14852 if (!SWIG_IsOK(ecode2)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14854 }
14855 arg2 = static_cast< int >(val2);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 (arg1)->SetColFormatBool(arg2);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 resultobj = SWIG_Py_Void();
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj = 0;
14871 wxGrid *arg1 = (wxGrid *) 0 ;
14872 int arg2 ;
14873 void *argp1 = 0 ;
14874 int res1 = 0 ;
14875 int val2 ;
14876 int ecode2 = 0 ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 char * kwnames[] = {
14880 (char *) "self",(char *) "col", NULL
14881 };
14882
14883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14887 }
14888 arg1 = reinterpret_cast< wxGrid * >(argp1);
14889 ecode2 = SWIG_AsVal_int(obj1, &val2);
14890 if (!SWIG_IsOK(ecode2)) {
14891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14892 }
14893 arg2 = static_cast< int >(val2);
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 (arg1)->SetColFormatNumber(arg2);
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 resultobj = SWIG_Py_Void();
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj = 0;
14909 wxGrid *arg1 = (wxGrid *) 0 ;
14910 int arg2 ;
14911 int arg3 = (int) -1 ;
14912 int arg4 = (int) -1 ;
14913 void *argp1 = 0 ;
14914 int res1 = 0 ;
14915 int val2 ;
14916 int ecode2 = 0 ;
14917 int val3 ;
14918 int ecode3 = 0 ;
14919 int val4 ;
14920 int ecode4 = 0 ;
14921 PyObject * obj0 = 0 ;
14922 PyObject * obj1 = 0 ;
14923 PyObject * obj2 = 0 ;
14924 PyObject * obj3 = 0 ;
14925 char * kwnames[] = {
14926 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14927 };
14928
14929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14933 }
14934 arg1 = reinterpret_cast< wxGrid * >(argp1);
14935 ecode2 = SWIG_AsVal_int(obj1, &val2);
14936 if (!SWIG_IsOK(ecode2)) {
14937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14938 }
14939 arg2 = static_cast< int >(val2);
14940 if (obj2) {
14941 ecode3 = SWIG_AsVal_int(obj2, &val3);
14942 if (!SWIG_IsOK(ecode3)) {
14943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14944 }
14945 arg3 = static_cast< int >(val3);
14946 }
14947 if (obj3) {
14948 ecode4 = SWIG_AsVal_int(obj3, &val4);
14949 if (!SWIG_IsOK(ecode4)) {
14950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14951 }
14952 arg4 = static_cast< int >(val4);
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_Py_Void();
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14968 PyObject *resultobj = 0;
14969 wxGrid *arg1 = (wxGrid *) 0 ;
14970 int arg2 ;
14971 wxString *arg3 = 0 ;
14972 void *argp1 = 0 ;
14973 int res1 = 0 ;
14974 int val2 ;
14975 int ecode2 = 0 ;
14976 bool temp3 = false ;
14977 PyObject * obj0 = 0 ;
14978 PyObject * obj1 = 0 ;
14979 PyObject * obj2 = 0 ;
14980 char * kwnames[] = {
14981 (char *) "self",(char *) "col",(char *) "typeName", NULL
14982 };
14983
14984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14986 if (!SWIG_IsOK(res1)) {
14987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14988 }
14989 arg1 = reinterpret_cast< wxGrid * >(argp1);
14990 ecode2 = SWIG_AsVal_int(obj1, &val2);
14991 if (!SWIG_IsOK(ecode2)) {
14992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14993 }
14994 arg2 = static_cast< int >(val2);
14995 {
14996 arg3 = wxString_in_helper(obj2);
14997 if (arg3 == NULL) SWIG_fail;
14998 temp3 = true;
14999 }
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_Py_Void();
15007 {
15008 if (temp3)
15009 delete arg3;
15010 }
15011 return resultobj;
15012 fail:
15013 {
15014 if (temp3)
15015 delete arg3;
15016 }
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15022 PyObject *resultobj = 0;
15023 wxGrid *arg1 = (wxGrid *) 0 ;
15024 bool arg2 = (bool) true ;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 bool val2 ;
15028 int ecode2 = 0 ;
15029 PyObject * obj0 = 0 ;
15030 PyObject * obj1 = 0 ;
15031 char * kwnames[] = {
15032 (char *) "self",(char *) "enable", NULL
15033 };
15034
15035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15037 if (!SWIG_IsOK(res1)) {
15038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15039 }
15040 arg1 = reinterpret_cast< wxGrid * >(argp1);
15041 if (obj1) {
15042 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15043 if (!SWIG_IsOK(ecode2)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15045 }
15046 arg2 = static_cast< bool >(val2);
15047 }
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 (arg1)->EnableGridLines(arg2);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 resultobj = SWIG_Py_Void();
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15062 PyObject *resultobj = 0;
15063 wxGrid *arg1 = (wxGrid *) 0 ;
15064 bool result;
15065 void *argp1 = 0 ;
15066 int res1 = 0 ;
15067 PyObject *swig_obj[1] ;
15068
15069 if (!args) SWIG_fail;
15070 swig_obj[0] = args;
15071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15072 if (!SWIG_IsOK(res1)) {
15073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15074 }
15075 arg1 = reinterpret_cast< wxGrid * >(argp1);
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (bool)(arg1)->GridLinesEnabled();
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 {
15083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15084 }
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 PyObject *resultobj = 0;
15093 wxGrid *arg1 = (wxGrid *) 0 ;
15094 int result;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 PyObject *swig_obj[1] ;
15098
15099 if (!args) SWIG_fail;
15100 swig_obj[0] = args;
15101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15102 if (!SWIG_IsOK(res1)) {
15103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15104 }
15105 arg1 = reinterpret_cast< wxGrid * >(argp1);
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 result = (int)(arg1)->GetDefaultRowSize();
15109 wxPyEndAllowThreads(__tstate);
15110 if (PyErr_Occurred()) SWIG_fail;
15111 }
15112 resultobj = SWIG_From_int(static_cast< int >(result));
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15120 PyObject *resultobj = 0;
15121 wxGrid *arg1 = (wxGrid *) 0 ;
15122 int arg2 ;
15123 int result;
15124 void *argp1 = 0 ;
15125 int res1 = 0 ;
15126 int val2 ;
15127 int ecode2 = 0 ;
15128 PyObject * obj0 = 0 ;
15129 PyObject * obj1 = 0 ;
15130 char * kwnames[] = {
15131 (char *) "self",(char *) "row", NULL
15132 };
15133
15134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15136 if (!SWIG_IsOK(res1)) {
15137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15138 }
15139 arg1 = reinterpret_cast< wxGrid * >(argp1);
15140 ecode2 = SWIG_AsVal_int(obj1, &val2);
15141 if (!SWIG_IsOK(ecode2)) {
15142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15143 }
15144 arg2 = static_cast< int >(val2);
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (int)(arg1)->GetRowSize(arg2);
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 resultobj = SWIG_From_int(static_cast< int >(result));
15152 return resultobj;
15153 fail:
15154 return NULL;
15155 }
15156
15157
15158 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15159 PyObject *resultobj = 0;
15160 wxGrid *arg1 = (wxGrid *) 0 ;
15161 int result;
15162 void *argp1 = 0 ;
15163 int res1 = 0 ;
15164 PyObject *swig_obj[1] ;
15165
15166 if (!args) SWIG_fail;
15167 swig_obj[0] = args;
15168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15169 if (!SWIG_IsOK(res1)) {
15170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15171 }
15172 arg1 = reinterpret_cast< wxGrid * >(argp1);
15173 {
15174 PyThreadState* __tstate = wxPyBeginAllowThreads();
15175 result = (int)(arg1)->GetDefaultColSize();
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 resultobj = SWIG_From_int(static_cast< int >(result));
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj = 0;
15188 wxGrid *arg1 = (wxGrid *) 0 ;
15189 int arg2 ;
15190 int result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 int val2 ;
15194 int ecode2 = 0 ;
15195 PyObject * obj0 = 0 ;
15196 PyObject * obj1 = 0 ;
15197 char * kwnames[] = {
15198 (char *) "self",(char *) "col", NULL
15199 };
15200
15201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15205 }
15206 arg1 = reinterpret_cast< wxGrid * >(argp1);
15207 ecode2 = SWIG_AsVal_int(obj1, &val2);
15208 if (!SWIG_IsOK(ecode2)) {
15209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15210 }
15211 arg2 = static_cast< int >(val2);
15212 {
15213 PyThreadState* __tstate = wxPyBeginAllowThreads();
15214 result = (int)(arg1)->GetColSize(arg2);
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 resultobj = SWIG_From_int(static_cast< int >(result));
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 PyObject *resultobj = 0;
15227 wxGrid *arg1 = (wxGrid *) 0 ;
15228 wxColour result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 PyObject *swig_obj[1] ;
15232
15233 if (!args) SWIG_fail;
15234 swig_obj[0] = args;
15235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15238 }
15239 arg1 = reinterpret_cast< wxGrid * >(argp1);
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (arg1)->GetDefaultCellBackgroundColour();
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj = 0;
15255 wxGrid *arg1 = (wxGrid *) 0 ;
15256 int arg2 ;
15257 int arg3 ;
15258 wxColour result;
15259 void *argp1 = 0 ;
15260 int res1 = 0 ;
15261 int val2 ;
15262 int ecode2 = 0 ;
15263 int val3 ;
15264 int ecode3 = 0 ;
15265 PyObject * obj0 = 0 ;
15266 PyObject * obj1 = 0 ;
15267 PyObject * obj2 = 0 ;
15268 char * kwnames[] = {
15269 (char *) "self",(char *) "row",(char *) "col", NULL
15270 };
15271
15272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15274 if (!SWIG_IsOK(res1)) {
15275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15276 }
15277 arg1 = reinterpret_cast< wxGrid * >(argp1);
15278 ecode2 = SWIG_AsVal_int(obj1, &val2);
15279 if (!SWIG_IsOK(ecode2)) {
15280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15281 }
15282 arg2 = static_cast< int >(val2);
15283 ecode3 = SWIG_AsVal_int(obj2, &val3);
15284 if (!SWIG_IsOK(ecode3)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15286 }
15287 arg3 = static_cast< int >(val3);
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15302 PyObject *resultobj = 0;
15303 wxGrid *arg1 = (wxGrid *) 0 ;
15304 wxColour result;
15305 void *argp1 = 0 ;
15306 int res1 = 0 ;
15307 PyObject *swig_obj[1] ;
15308
15309 if (!args) SWIG_fail;
15310 swig_obj[0] = args;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15314 }
15315 arg1 = reinterpret_cast< wxGrid * >(argp1);
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = (arg1)->GetDefaultCellTextColour();
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15330 PyObject *resultobj = 0;
15331 wxGrid *arg1 = (wxGrid *) 0 ;
15332 int arg2 ;
15333 int arg3 ;
15334 wxColour result;
15335 void *argp1 = 0 ;
15336 int res1 = 0 ;
15337 int val2 ;
15338 int ecode2 = 0 ;
15339 int val3 ;
15340 int ecode3 = 0 ;
15341 PyObject * obj0 = 0 ;
15342 PyObject * obj1 = 0 ;
15343 PyObject * obj2 = 0 ;
15344 char * kwnames[] = {
15345 (char *) "self",(char *) "row",(char *) "col", NULL
15346 };
15347
15348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15350 if (!SWIG_IsOK(res1)) {
15351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15352 }
15353 arg1 = reinterpret_cast< wxGrid * >(argp1);
15354 ecode2 = SWIG_AsVal_int(obj1, &val2);
15355 if (!SWIG_IsOK(ecode2)) {
15356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15357 }
15358 arg2 = static_cast< int >(val2);
15359 ecode3 = SWIG_AsVal_int(obj2, &val3);
15360 if (!SWIG_IsOK(ecode3)) {
15361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15362 }
15363 arg3 = static_cast< int >(val3);
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = (arg1)->GetCellTextColour(arg2,arg3);
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15378 PyObject *resultobj = 0;
15379 wxGrid *arg1 = (wxGrid *) 0 ;
15380 wxFont result;
15381 void *argp1 = 0 ;
15382 int res1 = 0 ;
15383 PyObject *swig_obj[1] ;
15384
15385 if (!args) SWIG_fail;
15386 swig_obj[0] = args;
15387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15388 if (!SWIG_IsOK(res1)) {
15389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15390 }
15391 arg1 = reinterpret_cast< wxGrid * >(argp1);
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 result = (arg1)->GetDefaultCellFont();
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15406 PyObject *resultobj = 0;
15407 wxGrid *arg1 = (wxGrid *) 0 ;
15408 int arg2 ;
15409 int arg3 ;
15410 wxFont result;
15411 void *argp1 = 0 ;
15412 int res1 = 0 ;
15413 int val2 ;
15414 int ecode2 = 0 ;
15415 int val3 ;
15416 int ecode3 = 0 ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 PyObject * obj2 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "row",(char *) "col", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15428 }
15429 arg1 = reinterpret_cast< wxGrid * >(argp1);
15430 ecode2 = SWIG_AsVal_int(obj1, &val2);
15431 if (!SWIG_IsOK(ecode2)) {
15432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15433 }
15434 arg2 = static_cast< int >(val2);
15435 ecode3 = SWIG_AsVal_int(obj2, &val3);
15436 if (!SWIG_IsOK(ecode3)) {
15437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15438 }
15439 arg3 = static_cast< int >(val3);
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 result = (arg1)->GetCellFont(arg2,arg3);
15443 wxPyEndAllowThreads(__tstate);
15444 if (PyErr_Occurred()) SWIG_fail;
15445 }
15446 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15447 return resultobj;
15448 fail:
15449 return NULL;
15450 }
15451
15452
15453 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15454 PyObject *resultobj = 0;
15455 wxGrid *arg1 = (wxGrid *) 0 ;
15456 int *arg2 = (int *) 0 ;
15457 int *arg3 = (int *) 0 ;
15458 void *argp1 = 0 ;
15459 int res1 = 0 ;
15460 int temp2 ;
15461 int res2 = SWIG_TMPOBJ ;
15462 int temp3 ;
15463 int res3 = SWIG_TMPOBJ ;
15464 PyObject *swig_obj[1] ;
15465
15466 arg2 = &temp2;
15467 arg3 = &temp3;
15468 if (!args) SWIG_fail;
15469 swig_obj[0] = args;
15470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15473 }
15474 arg1 = reinterpret_cast< wxGrid * >(argp1);
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = SWIG_Py_Void();
15482 if (SWIG_IsTmpObj(res2)) {
15483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15484 } else {
15485 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15487 }
15488 if (SWIG_IsTmpObj(res3)) {
15489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15490 } else {
15491 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15493 }
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15501 PyObject *resultobj = 0;
15502 wxGrid *arg1 = (wxGrid *) 0 ;
15503 int arg2 ;
15504 int arg3 ;
15505 int *arg4 = (int *) 0 ;
15506 int *arg5 = (int *) 0 ;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 int val2 ;
15510 int ecode2 = 0 ;
15511 int val3 ;
15512 int ecode3 = 0 ;
15513 int temp4 ;
15514 int res4 = SWIG_TMPOBJ ;
15515 int temp5 ;
15516 int res5 = SWIG_TMPOBJ ;
15517 PyObject * obj0 = 0 ;
15518 PyObject * obj1 = 0 ;
15519 PyObject * obj2 = 0 ;
15520 char * kwnames[] = {
15521 (char *) "self",(char *) "row",(char *) "col", NULL
15522 };
15523
15524 arg4 = &temp4;
15525 arg5 = &temp5;
15526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15528 if (!SWIG_IsOK(res1)) {
15529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15530 }
15531 arg1 = reinterpret_cast< wxGrid * >(argp1);
15532 ecode2 = SWIG_AsVal_int(obj1, &val2);
15533 if (!SWIG_IsOK(ecode2)) {
15534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15535 }
15536 arg2 = static_cast< int >(val2);
15537 ecode3 = SWIG_AsVal_int(obj2, &val3);
15538 if (!SWIG_IsOK(ecode3)) {
15539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15540 }
15541 arg3 = static_cast< int >(val3);
15542 {
15543 PyThreadState* __tstate = wxPyBeginAllowThreads();
15544 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15545 wxPyEndAllowThreads(__tstate);
15546 if (PyErr_Occurred()) SWIG_fail;
15547 }
15548 resultobj = SWIG_Py_Void();
15549 if (SWIG_IsTmpObj(res4)) {
15550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15551 } else {
15552 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15554 }
15555 if (SWIG_IsTmpObj(res5)) {
15556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15557 } else {
15558 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15560 }
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15568 PyObject *resultobj = 0;
15569 wxGrid *arg1 = (wxGrid *) 0 ;
15570 bool result;
15571 void *argp1 = 0 ;
15572 int res1 = 0 ;
15573 PyObject *swig_obj[1] ;
15574
15575 if (!args) SWIG_fail;
15576 swig_obj[0] = args;
15577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15578 if (!SWIG_IsOK(res1)) {
15579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15580 }
15581 arg1 = reinterpret_cast< wxGrid * >(argp1);
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 result = (bool)(arg1)->GetDefaultCellOverflow();
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 {
15589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15590 }
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj = 0;
15599 wxGrid *arg1 = (wxGrid *) 0 ;
15600 int arg2 ;
15601 int arg3 ;
15602 bool result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 int val2 ;
15606 int ecode2 = 0 ;
15607 int val3 ;
15608 int ecode3 = 0 ;
15609 PyObject * obj0 = 0 ;
15610 PyObject * obj1 = 0 ;
15611 PyObject * obj2 = 0 ;
15612 char * kwnames[] = {
15613 (char *) "self",(char *) "row",(char *) "col", NULL
15614 };
15615
15616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15618 if (!SWIG_IsOK(res1)) {
15619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15620 }
15621 arg1 = reinterpret_cast< wxGrid * >(argp1);
15622 ecode2 = SWIG_AsVal_int(obj1, &val2);
15623 if (!SWIG_IsOK(ecode2)) {
15624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15625 }
15626 arg2 = static_cast< int >(val2);
15627 ecode3 = SWIG_AsVal_int(obj2, &val3);
15628 if (!SWIG_IsOK(ecode3)) {
15629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15630 }
15631 arg3 = static_cast< int >(val3);
15632 {
15633 PyThreadState* __tstate = wxPyBeginAllowThreads();
15634 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15635 wxPyEndAllowThreads(__tstate);
15636 if (PyErr_Occurred()) SWIG_fail;
15637 }
15638 {
15639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15640 }
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15648 PyObject *resultobj = 0;
15649 wxGrid *arg1 = (wxGrid *) 0 ;
15650 int arg2 ;
15651 int arg3 ;
15652 int *arg4 = (int *) 0 ;
15653 int *arg5 = (int *) 0 ;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 int val2 ;
15657 int ecode2 = 0 ;
15658 int val3 ;
15659 int ecode3 = 0 ;
15660 int temp4 ;
15661 int res4 = SWIG_TMPOBJ ;
15662 int temp5 ;
15663 int res5 = SWIG_TMPOBJ ;
15664 PyObject * obj0 = 0 ;
15665 PyObject * obj1 = 0 ;
15666 PyObject * obj2 = 0 ;
15667 char * kwnames[] = {
15668 (char *) "self",(char *) "row",(char *) "col", NULL
15669 };
15670
15671 arg4 = &temp4;
15672 arg5 = &temp5;
15673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15677 }
15678 arg1 = reinterpret_cast< wxGrid * >(argp1);
15679 ecode2 = SWIG_AsVal_int(obj1, &val2);
15680 if (!SWIG_IsOK(ecode2)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15682 }
15683 arg2 = static_cast< int >(val2);
15684 ecode3 = SWIG_AsVal_int(obj2, &val3);
15685 if (!SWIG_IsOK(ecode3)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15687 }
15688 arg3 = static_cast< int >(val3);
15689 {
15690 PyThreadState* __tstate = wxPyBeginAllowThreads();
15691 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 resultobj = SWIG_Py_Void();
15696 if (SWIG_IsTmpObj(res4)) {
15697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15698 } else {
15699 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15701 }
15702 if (SWIG_IsTmpObj(res5)) {
15703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15704 } else {
15705 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15707 }
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15715 PyObject *resultobj = 0;
15716 wxGrid *arg1 = (wxGrid *) 0 ;
15717 int arg2 ;
15718 bool arg3 = (bool) false ;
15719 void *argp1 = 0 ;
15720 int res1 = 0 ;
15721 int val2 ;
15722 int ecode2 = 0 ;
15723 bool val3 ;
15724 int ecode3 = 0 ;
15725 PyObject * obj0 = 0 ;
15726 PyObject * obj1 = 0 ;
15727 PyObject * obj2 = 0 ;
15728 char * kwnames[] = {
15729 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15730 };
15731
15732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15736 }
15737 arg1 = reinterpret_cast< wxGrid * >(argp1);
15738 ecode2 = SWIG_AsVal_int(obj1, &val2);
15739 if (!SWIG_IsOK(ecode2)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15741 }
15742 arg2 = static_cast< int >(val2);
15743 if (obj2) {
15744 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15745 if (!SWIG_IsOK(ecode3)) {
15746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15747 }
15748 arg3 = static_cast< bool >(val3);
15749 }
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 (arg1)->SetDefaultRowSize(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_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15764 PyObject *resultobj = 0;
15765 wxGrid *arg1 = (wxGrid *) 0 ;
15766 int arg2 ;
15767 int arg3 ;
15768 void *argp1 = 0 ;
15769 int res1 = 0 ;
15770 int val2 ;
15771 int ecode2 = 0 ;
15772 int val3 ;
15773 int ecode3 = 0 ;
15774 PyObject * obj0 = 0 ;
15775 PyObject * obj1 = 0 ;
15776 PyObject * obj2 = 0 ;
15777 char * kwnames[] = {
15778 (char *) "self",(char *) "row",(char *) "height", NULL
15779 };
15780
15781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15783 if (!SWIG_IsOK(res1)) {
15784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15785 }
15786 arg1 = reinterpret_cast< wxGrid * >(argp1);
15787 ecode2 = SWIG_AsVal_int(obj1, &val2);
15788 if (!SWIG_IsOK(ecode2)) {
15789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15790 }
15791 arg2 = static_cast< int >(val2);
15792 ecode3 = SWIG_AsVal_int(obj2, &val3);
15793 if (!SWIG_IsOK(ecode3)) {
15794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15795 }
15796 arg3 = static_cast< int >(val3);
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 (arg1)->SetRowSize(arg2,arg3);
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 resultobj = SWIG_Py_Void();
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj = 0;
15812 wxGrid *arg1 = (wxGrid *) 0 ;
15813 int arg2 ;
15814 bool arg3 = (bool) false ;
15815 void *argp1 = 0 ;
15816 int res1 = 0 ;
15817 int val2 ;
15818 int ecode2 = 0 ;
15819 bool val3 ;
15820 int ecode3 = 0 ;
15821 PyObject * obj0 = 0 ;
15822 PyObject * obj1 = 0 ;
15823 PyObject * obj2 = 0 ;
15824 char * kwnames[] = {
15825 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15826 };
15827
15828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15830 if (!SWIG_IsOK(res1)) {
15831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15832 }
15833 arg1 = reinterpret_cast< wxGrid * >(argp1);
15834 ecode2 = SWIG_AsVal_int(obj1, &val2);
15835 if (!SWIG_IsOK(ecode2)) {
15836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15837 }
15838 arg2 = static_cast< int >(val2);
15839 if (obj2) {
15840 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15841 if (!SWIG_IsOK(ecode3)) {
15842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15843 }
15844 arg3 = static_cast< bool >(val3);
15845 }
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 (arg1)->SetDefaultColSize(arg2,arg3);
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_Py_Void();
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 wxGrid *arg1 = (wxGrid *) 0 ;
15862 int arg2 ;
15863 int arg3 ;
15864 void *argp1 = 0 ;
15865 int res1 = 0 ;
15866 int val2 ;
15867 int ecode2 = 0 ;
15868 int val3 ;
15869 int ecode3 = 0 ;
15870 PyObject * obj0 = 0 ;
15871 PyObject * obj1 = 0 ;
15872 PyObject * obj2 = 0 ;
15873 char * kwnames[] = {
15874 (char *) "self",(char *) "col",(char *) "width", NULL
15875 };
15876
15877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15879 if (!SWIG_IsOK(res1)) {
15880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15881 }
15882 arg1 = reinterpret_cast< wxGrid * >(argp1);
15883 ecode2 = SWIG_AsVal_int(obj1, &val2);
15884 if (!SWIG_IsOK(ecode2)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15886 }
15887 arg2 = static_cast< int >(val2);
15888 ecode3 = SWIG_AsVal_int(obj2, &val3);
15889 if (!SWIG_IsOK(ecode3)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15891 }
15892 arg3 = static_cast< int >(val3);
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 (arg1)->SetColSize(arg2,arg3);
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_Py_Void();
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15907 PyObject *resultobj = 0;
15908 wxGrid *arg1 = (wxGrid *) 0 ;
15909 int arg2 ;
15910 int result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 int val2 ;
15914 int ecode2 = 0 ;
15915 PyObject * obj0 = 0 ;
15916 PyObject * obj1 = 0 ;
15917 char * kwnames[] = {
15918 (char *) "self",(char *) "colPos", NULL
15919 };
15920
15921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15923 if (!SWIG_IsOK(res1)) {
15924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15925 }
15926 arg1 = reinterpret_cast< wxGrid * >(argp1);
15927 ecode2 = SWIG_AsVal_int(obj1, &val2);
15928 if (!SWIG_IsOK(ecode2)) {
15929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15930 }
15931 arg2 = static_cast< int >(val2);
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 resultobj = SWIG_From_int(static_cast< int >(result));
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj = 0;
15947 wxGrid *arg1 = (wxGrid *) 0 ;
15948 int arg2 ;
15949 int arg3 ;
15950 void *argp1 = 0 ;
15951 int res1 = 0 ;
15952 int val2 ;
15953 int ecode2 = 0 ;
15954 int val3 ;
15955 int ecode3 = 0 ;
15956 PyObject * obj0 = 0 ;
15957 PyObject * obj1 = 0 ;
15958 PyObject * obj2 = 0 ;
15959 char * kwnames[] = {
15960 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15961 };
15962
15963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15965 if (!SWIG_IsOK(res1)) {
15966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15967 }
15968 arg1 = reinterpret_cast< wxGrid * >(argp1);
15969 ecode2 = SWIG_AsVal_int(obj1, &val2);
15970 if (!SWIG_IsOK(ecode2)) {
15971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15972 }
15973 arg2 = static_cast< int >(val2);
15974 ecode3 = SWIG_AsVal_int(obj2, &val3);
15975 if (!SWIG_IsOK(ecode3)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15977 }
15978 arg3 = static_cast< int >(val3);
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 (arg1)->SetColPos(arg2,arg3);
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = SWIG_Py_Void();
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15993 PyObject *resultobj = 0;
15994 wxGrid *arg1 = (wxGrid *) 0 ;
15995 int arg2 ;
15996 int result;
15997 void *argp1 = 0 ;
15998 int res1 = 0 ;
15999 int val2 ;
16000 int ecode2 = 0 ;
16001 PyObject * obj0 = 0 ;
16002 PyObject * obj1 = 0 ;
16003 char * kwnames[] = {
16004 (char *) "self",(char *) "colID", NULL
16005 };
16006
16007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16011 }
16012 arg1 = reinterpret_cast< wxGrid * >(argp1);
16013 ecode2 = SWIG_AsVal_int(obj1, &val2);
16014 if (!SWIG_IsOK(ecode2)) {
16015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16016 }
16017 arg2 = static_cast< int >(val2);
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 resultobj = SWIG_From_int(static_cast< int >(result));
16025 return resultobj;
16026 fail:
16027 return NULL;
16028 }
16029
16030
16031 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj = 0;
16033 wxGrid *arg1 = (wxGrid *) 0 ;
16034 int arg2 ;
16035 bool arg3 = (bool) true ;
16036 void *argp1 = 0 ;
16037 int res1 = 0 ;
16038 int val2 ;
16039 int ecode2 = 0 ;
16040 bool val3 ;
16041 int ecode3 = 0 ;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 PyObject * obj2 = 0 ;
16045 char * kwnames[] = {
16046 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16047 };
16048
16049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16051 if (!SWIG_IsOK(res1)) {
16052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16053 }
16054 arg1 = reinterpret_cast< wxGrid * >(argp1);
16055 ecode2 = SWIG_AsVal_int(obj1, &val2);
16056 if (!SWIG_IsOK(ecode2)) {
16057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16058 }
16059 arg2 = static_cast< int >(val2);
16060 if (obj2) {
16061 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16062 if (!SWIG_IsOK(ecode3)) {
16063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16064 }
16065 arg3 = static_cast< bool >(val3);
16066 }
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 (arg1)->AutoSizeColumn(arg2,arg3);
16070 wxPyEndAllowThreads(__tstate);
16071 if (PyErr_Occurred()) SWIG_fail;
16072 }
16073 resultobj = SWIG_Py_Void();
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj = 0;
16082 wxGrid *arg1 = (wxGrid *) 0 ;
16083 int arg2 ;
16084 bool arg3 = (bool) true ;
16085 void *argp1 = 0 ;
16086 int res1 = 0 ;
16087 int val2 ;
16088 int ecode2 = 0 ;
16089 bool val3 ;
16090 int ecode3 = 0 ;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 PyObject * obj2 = 0 ;
16094 char * kwnames[] = {
16095 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16096 };
16097
16098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16100 if (!SWIG_IsOK(res1)) {
16101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16102 }
16103 arg1 = reinterpret_cast< wxGrid * >(argp1);
16104 ecode2 = SWIG_AsVal_int(obj1, &val2);
16105 if (!SWIG_IsOK(ecode2)) {
16106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16107 }
16108 arg2 = static_cast< int >(val2);
16109 if (obj2) {
16110 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16111 if (!SWIG_IsOK(ecode3)) {
16112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16113 }
16114 arg3 = static_cast< bool >(val3);
16115 }
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 (arg1)->AutoSizeRow(arg2,arg3);
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_Py_Void();
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16130 PyObject *resultobj = 0;
16131 wxGrid *arg1 = (wxGrid *) 0 ;
16132 bool arg2 = (bool) true ;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 bool val2 ;
16136 int ecode2 = 0 ;
16137 PyObject * obj0 = 0 ;
16138 PyObject * obj1 = 0 ;
16139 char * kwnames[] = {
16140 (char *) "self",(char *) "setAsMin", NULL
16141 };
16142
16143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16145 if (!SWIG_IsOK(res1)) {
16146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16147 }
16148 arg1 = reinterpret_cast< wxGrid * >(argp1);
16149 if (obj1) {
16150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16151 if (!SWIG_IsOK(ecode2)) {
16152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16153 }
16154 arg2 = static_cast< bool >(val2);
16155 }
16156 {
16157 PyThreadState* __tstate = wxPyBeginAllowThreads();
16158 (arg1)->AutoSizeColumns(arg2);
16159 wxPyEndAllowThreads(__tstate);
16160 if (PyErr_Occurred()) SWIG_fail;
16161 }
16162 resultobj = SWIG_Py_Void();
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj = 0;
16171 wxGrid *arg1 = (wxGrid *) 0 ;
16172 bool arg2 = (bool) true ;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 bool val2 ;
16176 int ecode2 = 0 ;
16177 PyObject * obj0 = 0 ;
16178 PyObject * obj1 = 0 ;
16179 char * kwnames[] = {
16180 (char *) "self",(char *) "setAsMin", NULL
16181 };
16182
16183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16185 if (!SWIG_IsOK(res1)) {
16186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16187 }
16188 arg1 = reinterpret_cast< wxGrid * >(argp1);
16189 if (obj1) {
16190 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16191 if (!SWIG_IsOK(ecode2)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16193 }
16194 arg2 = static_cast< bool >(val2);
16195 }
16196 {
16197 PyThreadState* __tstate = wxPyBeginAllowThreads();
16198 (arg1)->AutoSizeRows(arg2);
16199 wxPyEndAllowThreads(__tstate);
16200 if (PyErr_Occurred()) SWIG_fail;
16201 }
16202 resultobj = SWIG_Py_Void();
16203 return resultobj;
16204 fail:
16205 return NULL;
16206 }
16207
16208
16209 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16210 PyObject *resultobj = 0;
16211 wxGrid *arg1 = (wxGrid *) 0 ;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 PyObject *swig_obj[1] ;
16215
16216 if (!args) SWIG_fail;
16217 swig_obj[0] = args;
16218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16219 if (!SWIG_IsOK(res1)) {
16220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16221 }
16222 arg1 = reinterpret_cast< wxGrid * >(argp1);
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 (arg1)->AutoSize();
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 resultobj = SWIG_Py_Void();
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16237 PyObject *resultobj = 0;
16238 wxGrid *arg1 = (wxGrid *) 0 ;
16239 int arg2 ;
16240 void *argp1 = 0 ;
16241 int res1 = 0 ;
16242 int val2 ;
16243 int ecode2 = 0 ;
16244 PyObject * obj0 = 0 ;
16245 PyObject * obj1 = 0 ;
16246 char * kwnames[] = {
16247 (char *) "self",(char *) "row", NULL
16248 };
16249
16250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16254 }
16255 arg1 = reinterpret_cast< wxGrid * >(argp1);
16256 ecode2 = SWIG_AsVal_int(obj1, &val2);
16257 if (!SWIG_IsOK(ecode2)) {
16258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16259 }
16260 arg2 = static_cast< int >(val2);
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 (arg1)->AutoSizeRowLabelSize(arg2);
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 resultobj = SWIG_Py_Void();
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxGrid *arg1 = (wxGrid *) 0 ;
16277 int arg2 ;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 int val2 ;
16281 int ecode2 = 0 ;
16282 PyObject * obj0 = 0 ;
16283 PyObject * obj1 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "self",(char *) "col", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16290 if (!SWIG_IsOK(res1)) {
16291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16292 }
16293 arg1 = reinterpret_cast< wxGrid * >(argp1);
16294 ecode2 = SWIG_AsVal_int(obj1, &val2);
16295 if (!SWIG_IsOK(ecode2)) {
16296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16297 }
16298 arg2 = static_cast< int >(val2);
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 (arg1)->AutoSizeColLabelSize(arg2);
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 resultobj = SWIG_Py_Void();
16306 return resultobj;
16307 fail:
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16313 PyObject *resultobj = 0;
16314 wxGrid *arg1 = (wxGrid *) 0 ;
16315 int arg2 ;
16316 int arg3 ;
16317 void *argp1 = 0 ;
16318 int res1 = 0 ;
16319 int val2 ;
16320 int ecode2 = 0 ;
16321 int val3 ;
16322 int ecode3 = 0 ;
16323 PyObject * obj0 = 0 ;
16324 PyObject * obj1 = 0 ;
16325 PyObject * obj2 = 0 ;
16326 char * kwnames[] = {
16327 (char *) "self",(char *) "col",(char *) "width", NULL
16328 };
16329
16330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16332 if (!SWIG_IsOK(res1)) {
16333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16334 }
16335 arg1 = reinterpret_cast< wxGrid * >(argp1);
16336 ecode2 = SWIG_AsVal_int(obj1, &val2);
16337 if (!SWIG_IsOK(ecode2)) {
16338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16339 }
16340 arg2 = static_cast< int >(val2);
16341 ecode3 = SWIG_AsVal_int(obj2, &val3);
16342 if (!SWIG_IsOK(ecode3)) {
16343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16344 }
16345 arg3 = static_cast< int >(val3);
16346 {
16347 PyThreadState* __tstate = wxPyBeginAllowThreads();
16348 (arg1)->SetColMinimalWidth(arg2,arg3);
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 resultobj = SWIG_Py_Void();
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj = 0;
16361 wxGrid *arg1 = (wxGrid *) 0 ;
16362 int arg2 ;
16363 int arg3 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 int val2 ;
16367 int ecode2 = 0 ;
16368 int val3 ;
16369 int ecode3 = 0 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 PyObject * obj2 = 0 ;
16373 char * kwnames[] = {
16374 (char *) "self",(char *) "row",(char *) "width", NULL
16375 };
16376
16377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16379 if (!SWIG_IsOK(res1)) {
16380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16381 }
16382 arg1 = reinterpret_cast< wxGrid * >(argp1);
16383 ecode2 = SWIG_AsVal_int(obj1, &val2);
16384 if (!SWIG_IsOK(ecode2)) {
16385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16386 }
16387 arg2 = static_cast< int >(val2);
16388 ecode3 = SWIG_AsVal_int(obj2, &val3);
16389 if (!SWIG_IsOK(ecode3)) {
16390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16391 }
16392 arg3 = static_cast< int >(val3);
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 (arg1)->SetRowMinimalHeight(arg2,arg3);
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 resultobj = SWIG_Py_Void();
16400 return resultobj;
16401 fail:
16402 return NULL;
16403 }
16404
16405
16406 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16407 PyObject *resultobj = 0;
16408 wxGrid *arg1 = (wxGrid *) 0 ;
16409 int arg2 ;
16410 void *argp1 = 0 ;
16411 int res1 = 0 ;
16412 int val2 ;
16413 int ecode2 = 0 ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "self",(char *) "width", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16424 }
16425 arg1 = reinterpret_cast< wxGrid * >(argp1);
16426 ecode2 = SWIG_AsVal_int(obj1, &val2);
16427 if (!SWIG_IsOK(ecode2)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16429 }
16430 arg2 = static_cast< int >(val2);
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 (arg1)->SetColMinimalAcceptableWidth(arg2);
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_Py_Void();
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj = 0;
16446 wxGrid *arg1 = (wxGrid *) 0 ;
16447 int arg2 ;
16448 void *argp1 = 0 ;
16449 int res1 = 0 ;
16450 int val2 ;
16451 int ecode2 = 0 ;
16452 PyObject * obj0 = 0 ;
16453 PyObject * obj1 = 0 ;
16454 char * kwnames[] = {
16455 (char *) "self",(char *) "width", NULL
16456 };
16457
16458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16462 }
16463 arg1 = reinterpret_cast< wxGrid * >(argp1);
16464 ecode2 = SWIG_AsVal_int(obj1, &val2);
16465 if (!SWIG_IsOK(ecode2)) {
16466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16467 }
16468 arg2 = static_cast< int >(val2);
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16472 wxPyEndAllowThreads(__tstate);
16473 if (PyErr_Occurred()) SWIG_fail;
16474 }
16475 resultobj = SWIG_Py_Void();
16476 return resultobj;
16477 fail:
16478 return NULL;
16479 }
16480
16481
16482 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16483 PyObject *resultobj = 0;
16484 wxGrid *arg1 = (wxGrid *) 0 ;
16485 int result;
16486 void *argp1 = 0 ;
16487 int res1 = 0 ;
16488 PyObject *swig_obj[1] ;
16489
16490 if (!args) SWIG_fail;
16491 swig_obj[0] = args;
16492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16493 if (!SWIG_IsOK(res1)) {
16494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16495 }
16496 arg1 = reinterpret_cast< wxGrid * >(argp1);
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_From_int(static_cast< int >(result));
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16511 PyObject *resultobj = 0;
16512 wxGrid *arg1 = (wxGrid *) 0 ;
16513 int result;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 PyObject *swig_obj[1] ;
16517
16518 if (!args) SWIG_fail;
16519 swig_obj[0] = args;
16520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16523 }
16524 arg1 = reinterpret_cast< wxGrid * >(argp1);
16525 {
16526 PyThreadState* __tstate = wxPyBeginAllowThreads();
16527 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16528 wxPyEndAllowThreads(__tstate);
16529 if (PyErr_Occurred()) SWIG_fail;
16530 }
16531 resultobj = SWIG_From_int(static_cast< int >(result));
16532 return resultobj;
16533 fail:
16534 return NULL;
16535 }
16536
16537
16538 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16539 PyObject *resultobj = 0;
16540 wxGrid *arg1 = (wxGrid *) 0 ;
16541 wxColour *arg2 = 0 ;
16542 void *argp1 = 0 ;
16543 int res1 = 0 ;
16544 wxColour temp2 ;
16545 PyObject * obj0 = 0 ;
16546 PyObject * obj1 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *)"arg2", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16555 }
16556 arg1 = reinterpret_cast< wxGrid * >(argp1);
16557 {
16558 arg2 = &temp2;
16559 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16560 }
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 resultobj = SWIG_Py_Void();
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxGrid *arg1 = (wxGrid *) 0 ;
16577 int arg2 ;
16578 int arg3 ;
16579 wxColour *arg4 = 0 ;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 int val2 ;
16583 int ecode2 = 0 ;
16584 int val3 ;
16585 int ecode3 = 0 ;
16586 wxColour temp4 ;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 PyObject * obj2 = 0 ;
16590 PyObject * obj3 = 0 ;
16591 char * kwnames[] = {
16592 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16593 };
16594
16595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16597 if (!SWIG_IsOK(res1)) {
16598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16599 }
16600 arg1 = reinterpret_cast< wxGrid * >(argp1);
16601 ecode2 = SWIG_AsVal_int(obj1, &val2);
16602 if (!SWIG_IsOK(ecode2)) {
16603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16604 }
16605 arg2 = static_cast< int >(val2);
16606 ecode3 = SWIG_AsVal_int(obj2, &val3);
16607 if (!SWIG_IsOK(ecode3)) {
16608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16609 }
16610 arg3 = static_cast< int >(val3);
16611 {
16612 arg4 = &temp4;
16613 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16614 }
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 resultobj = SWIG_Py_Void();
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj = 0;
16630 wxGrid *arg1 = (wxGrid *) 0 ;
16631 wxColour *arg2 = 0 ;
16632 void *argp1 = 0 ;
16633 int res1 = 0 ;
16634 wxColour temp2 ;
16635 PyObject * obj0 = 0 ;
16636 PyObject * obj1 = 0 ;
16637 char * kwnames[] = {
16638 (char *) "self",(char *)"arg2", NULL
16639 };
16640
16641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16643 if (!SWIG_IsOK(res1)) {
16644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16645 }
16646 arg1 = reinterpret_cast< wxGrid * >(argp1);
16647 {
16648 arg2 = &temp2;
16649 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16650 }
16651 {
16652 PyThreadState* __tstate = wxPyBeginAllowThreads();
16653 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 resultobj = SWIG_Py_Void();
16658 return resultobj;
16659 fail:
16660 return NULL;
16661 }
16662
16663
16664 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16665 PyObject *resultobj = 0;
16666 wxGrid *arg1 = (wxGrid *) 0 ;
16667 int arg2 ;
16668 int arg3 ;
16669 wxColour *arg4 = 0 ;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 int val2 ;
16673 int ecode2 = 0 ;
16674 int val3 ;
16675 int ecode3 = 0 ;
16676 wxColour temp4 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 PyObject * obj2 = 0 ;
16680 PyObject * obj3 = 0 ;
16681 char * kwnames[] = {
16682 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16683 };
16684
16685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16687 if (!SWIG_IsOK(res1)) {
16688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16689 }
16690 arg1 = reinterpret_cast< wxGrid * >(argp1);
16691 ecode2 = SWIG_AsVal_int(obj1, &val2);
16692 if (!SWIG_IsOK(ecode2)) {
16693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16694 }
16695 arg2 = static_cast< int >(val2);
16696 ecode3 = SWIG_AsVal_int(obj2, &val3);
16697 if (!SWIG_IsOK(ecode3)) {
16698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16699 }
16700 arg3 = static_cast< int >(val3);
16701 {
16702 arg4 = &temp4;
16703 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16704 }
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 resultobj = SWIG_Py_Void();
16712 return resultobj;
16713 fail:
16714 return NULL;
16715 }
16716
16717
16718 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16719 PyObject *resultobj = 0;
16720 wxGrid *arg1 = (wxGrid *) 0 ;
16721 wxFont *arg2 = 0 ;
16722 void *argp1 = 0 ;
16723 int res1 = 0 ;
16724 void *argp2 = 0 ;
16725 int res2 = 0 ;
16726 PyObject * obj0 = 0 ;
16727 PyObject * obj1 = 0 ;
16728 char * kwnames[] = {
16729 (char *) "self",(char *)"arg2", NULL
16730 };
16731
16732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16734 if (!SWIG_IsOK(res1)) {
16735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16736 }
16737 arg1 = reinterpret_cast< wxGrid * >(argp1);
16738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16739 if (!SWIG_IsOK(res2)) {
16740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16741 }
16742 if (!argp2) {
16743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16744 }
16745 arg2 = reinterpret_cast< wxFont * >(argp2);
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 resultobj = SWIG_Py_Void();
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj = 0;
16761 wxGrid *arg1 = (wxGrid *) 0 ;
16762 int arg2 ;
16763 int arg3 ;
16764 wxFont *arg4 = 0 ;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 int val2 ;
16768 int ecode2 = 0 ;
16769 int val3 ;
16770 int ecode3 = 0 ;
16771 void *argp4 = 0 ;
16772 int res4 = 0 ;
16773 PyObject * obj0 = 0 ;
16774 PyObject * obj1 = 0 ;
16775 PyObject * obj2 = 0 ;
16776 PyObject * obj3 = 0 ;
16777 char * kwnames[] = {
16778 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16779 };
16780
16781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16783 if (!SWIG_IsOK(res1)) {
16784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16785 }
16786 arg1 = reinterpret_cast< wxGrid * >(argp1);
16787 ecode2 = SWIG_AsVal_int(obj1, &val2);
16788 if (!SWIG_IsOK(ecode2)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16790 }
16791 arg2 = static_cast< int >(val2);
16792 ecode3 = SWIG_AsVal_int(obj2, &val3);
16793 if (!SWIG_IsOK(ecode3)) {
16794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16795 }
16796 arg3 = static_cast< int >(val3);
16797 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16798 if (!SWIG_IsOK(res4)) {
16799 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16800 }
16801 if (!argp4) {
16802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16803 }
16804 arg4 = reinterpret_cast< wxFont * >(argp4);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_Py_Void();
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxGrid *arg1 = (wxGrid *) 0 ;
16821 int arg2 ;
16822 int arg3 ;
16823 void *argp1 = 0 ;
16824 int res1 = 0 ;
16825 int val2 ;
16826 int ecode2 = 0 ;
16827 int val3 ;
16828 int ecode3 = 0 ;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 PyObject * obj2 = 0 ;
16832 char * kwnames[] = {
16833 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16834 };
16835
16836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16838 if (!SWIG_IsOK(res1)) {
16839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16840 }
16841 arg1 = reinterpret_cast< wxGrid * >(argp1);
16842 ecode2 = SWIG_AsVal_int(obj1, &val2);
16843 if (!SWIG_IsOK(ecode2)) {
16844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16845 }
16846 arg2 = static_cast< int >(val2);
16847 ecode3 = SWIG_AsVal_int(obj2, &val3);
16848 if (!SWIG_IsOK(ecode3)) {
16849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16850 }
16851 arg3 = static_cast< int >(val3);
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 resultobj = SWIG_Py_Void();
16859 return resultobj;
16860 fail:
16861 return NULL;
16862 }
16863
16864
16865 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16866 PyObject *resultobj = 0;
16867 wxGrid *arg1 = (wxGrid *) 0 ;
16868 int arg2 ;
16869 int arg3 ;
16870 int arg4 ;
16871 int arg5 ;
16872 void *argp1 = 0 ;
16873 int res1 = 0 ;
16874 int val2 ;
16875 int ecode2 = 0 ;
16876 int val3 ;
16877 int ecode3 = 0 ;
16878 int val4 ;
16879 int ecode4 = 0 ;
16880 int val5 ;
16881 int ecode5 = 0 ;
16882 PyObject * obj0 = 0 ;
16883 PyObject * obj1 = 0 ;
16884 PyObject * obj2 = 0 ;
16885 PyObject * obj3 = 0 ;
16886 PyObject * obj4 = 0 ;
16887 char * kwnames[] = {
16888 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16889 };
16890
16891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16895 }
16896 arg1 = reinterpret_cast< wxGrid * >(argp1);
16897 ecode2 = SWIG_AsVal_int(obj1, &val2);
16898 if (!SWIG_IsOK(ecode2)) {
16899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16900 }
16901 arg2 = static_cast< int >(val2);
16902 ecode3 = SWIG_AsVal_int(obj2, &val3);
16903 if (!SWIG_IsOK(ecode3)) {
16904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16905 }
16906 arg3 = static_cast< int >(val3);
16907 ecode4 = SWIG_AsVal_int(obj3, &val4);
16908 if (!SWIG_IsOK(ecode4)) {
16909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16910 }
16911 arg4 = static_cast< int >(val4);
16912 ecode5 = SWIG_AsVal_int(obj4, &val5);
16913 if (!SWIG_IsOK(ecode5)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16915 }
16916 arg5 = static_cast< int >(val5);
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = SWIG_Py_Void();
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj = 0;
16932 wxGrid *arg1 = (wxGrid *) 0 ;
16933 bool arg2 ;
16934 void *argp1 = 0 ;
16935 int res1 = 0 ;
16936 bool val2 ;
16937 int ecode2 = 0 ;
16938 PyObject * obj0 = 0 ;
16939 PyObject * obj1 = 0 ;
16940 char * kwnames[] = {
16941 (char *) "self",(char *) "allow", NULL
16942 };
16943
16944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16946 if (!SWIG_IsOK(res1)) {
16947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16948 }
16949 arg1 = reinterpret_cast< wxGrid * >(argp1);
16950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16951 if (!SWIG_IsOK(ecode2)) {
16952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16953 }
16954 arg2 = static_cast< bool >(val2);
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 (arg1)->SetDefaultCellOverflow(arg2);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 resultobj = SWIG_Py_Void();
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj = 0;
16970 wxGrid *arg1 = (wxGrid *) 0 ;
16971 int arg2 ;
16972 int arg3 ;
16973 bool arg4 ;
16974 void *argp1 = 0 ;
16975 int res1 = 0 ;
16976 int val2 ;
16977 int ecode2 = 0 ;
16978 int val3 ;
16979 int ecode3 = 0 ;
16980 bool val4 ;
16981 int ecode4 = 0 ;
16982 PyObject * obj0 = 0 ;
16983 PyObject * obj1 = 0 ;
16984 PyObject * obj2 = 0 ;
16985 PyObject * obj3 = 0 ;
16986 char * kwnames[] = {
16987 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16988 };
16989
16990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16992 if (!SWIG_IsOK(res1)) {
16993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16994 }
16995 arg1 = reinterpret_cast< wxGrid * >(argp1);
16996 ecode2 = SWIG_AsVal_int(obj1, &val2);
16997 if (!SWIG_IsOK(ecode2)) {
16998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16999 }
17000 arg2 = static_cast< int >(val2);
17001 ecode3 = SWIG_AsVal_int(obj2, &val3);
17002 if (!SWIG_IsOK(ecode3)) {
17003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17004 }
17005 arg3 = static_cast< int >(val3);
17006 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17007 if (!SWIG_IsOK(ecode4)) {
17008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17009 }
17010 arg4 = static_cast< bool >(val4);
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 resultobj = SWIG_Py_Void();
17018 return resultobj;
17019 fail:
17020 return NULL;
17021 }
17022
17023
17024 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17025 PyObject *resultobj = 0;
17026 wxGrid *arg1 = (wxGrid *) 0 ;
17027 int arg2 ;
17028 int arg3 ;
17029 int arg4 ;
17030 int arg5 ;
17031 void *argp1 = 0 ;
17032 int res1 = 0 ;
17033 int val2 ;
17034 int ecode2 = 0 ;
17035 int val3 ;
17036 int ecode3 = 0 ;
17037 int val4 ;
17038 int ecode4 = 0 ;
17039 int val5 ;
17040 int ecode5 = 0 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 PyObject * obj3 = 0 ;
17045 PyObject * obj4 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17048 };
17049
17050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17052 if (!SWIG_IsOK(res1)) {
17053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17054 }
17055 arg1 = reinterpret_cast< wxGrid * >(argp1);
17056 ecode2 = SWIG_AsVal_int(obj1, &val2);
17057 if (!SWIG_IsOK(ecode2)) {
17058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17059 }
17060 arg2 = static_cast< int >(val2);
17061 ecode3 = SWIG_AsVal_int(obj2, &val3);
17062 if (!SWIG_IsOK(ecode3)) {
17063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17064 }
17065 arg3 = static_cast< int >(val3);
17066 ecode4 = SWIG_AsVal_int(obj3, &val4);
17067 if (!SWIG_IsOK(ecode4)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17069 }
17070 arg4 = static_cast< int >(val4);
17071 ecode5 = SWIG_AsVal_int(obj4, &val5);
17072 if (!SWIG_IsOK(ecode5)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17074 }
17075 arg5 = static_cast< int >(val5);
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_Py_Void();
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj = 0;
17091 wxGrid *arg1 = (wxGrid *) 0 ;
17092 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17093 void *argp1 = 0 ;
17094 int res1 = 0 ;
17095 void *argp2 = 0 ;
17096 int res2 = 0 ;
17097 PyObject * obj0 = 0 ;
17098 PyObject * obj1 = 0 ;
17099 char * kwnames[] = {
17100 (char *) "self",(char *) "renderer", NULL
17101 };
17102
17103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17105 if (!SWIG_IsOK(res1)) {
17106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17107 }
17108 arg1 = reinterpret_cast< wxGrid * >(argp1);
17109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17110 if (!SWIG_IsOK(res2)) {
17111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17112 }
17113 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 (arg1)->SetDefaultRenderer(arg2);
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 resultobj = SWIG_Py_Void();
17121 return resultobj;
17122 fail:
17123 return NULL;
17124 }
17125
17126
17127 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17128 PyObject *resultobj = 0;
17129 wxGrid *arg1 = (wxGrid *) 0 ;
17130 int arg2 ;
17131 int arg3 ;
17132 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17133 void *argp1 = 0 ;
17134 int res1 = 0 ;
17135 int val2 ;
17136 int ecode2 = 0 ;
17137 int val3 ;
17138 int ecode3 = 0 ;
17139 void *argp4 = 0 ;
17140 int res4 = 0 ;
17141 PyObject * obj0 = 0 ;
17142 PyObject * obj1 = 0 ;
17143 PyObject * obj2 = 0 ;
17144 PyObject * obj3 = 0 ;
17145 char * kwnames[] = {
17146 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17147 };
17148
17149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17151 if (!SWIG_IsOK(res1)) {
17152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17153 }
17154 arg1 = reinterpret_cast< wxGrid * >(argp1);
17155 ecode2 = SWIG_AsVal_int(obj1, &val2);
17156 if (!SWIG_IsOK(ecode2)) {
17157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17158 }
17159 arg2 = static_cast< int >(val2);
17160 ecode3 = SWIG_AsVal_int(obj2, &val3);
17161 if (!SWIG_IsOK(ecode3)) {
17162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17163 }
17164 arg3 = static_cast< int >(val3);
17165 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17166 if (!SWIG_IsOK(res4)) {
17167 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17168 }
17169 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 resultobj = SWIG_Py_Void();
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17184 PyObject *resultobj = 0;
17185 wxGrid *arg1 = (wxGrid *) 0 ;
17186 wxGridCellRenderer *result = 0 ;
17187 void *argp1 = 0 ;
17188 int res1 = 0 ;
17189 PyObject *swig_obj[1] ;
17190
17191 if (!args) SWIG_fail;
17192 swig_obj[0] = args;
17193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17194 if (!SWIG_IsOK(res1)) {
17195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17196 }
17197 arg1 = reinterpret_cast< wxGrid * >(argp1);
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17201 wxPyEndAllowThreads(__tstate);
17202 if (PyErr_Occurred()) SWIG_fail;
17203 }
17204 {
17205 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17206 }
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17214 PyObject *resultobj = 0;
17215 wxGrid *arg1 = (wxGrid *) 0 ;
17216 int arg2 ;
17217 int arg3 ;
17218 wxGridCellRenderer *result = 0 ;
17219 void *argp1 = 0 ;
17220 int res1 = 0 ;
17221 int val2 ;
17222 int ecode2 = 0 ;
17223 int val3 ;
17224 int ecode3 = 0 ;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 PyObject * obj2 = 0 ;
17228 char * kwnames[] = {
17229 (char *) "self",(char *) "row",(char *) "col", NULL
17230 };
17231
17232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17234 if (!SWIG_IsOK(res1)) {
17235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17236 }
17237 arg1 = reinterpret_cast< wxGrid * >(argp1);
17238 ecode2 = SWIG_AsVal_int(obj1, &val2);
17239 if (!SWIG_IsOK(ecode2)) {
17240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17241 }
17242 arg2 = static_cast< int >(val2);
17243 ecode3 = SWIG_AsVal_int(obj2, &val3);
17244 if (!SWIG_IsOK(ecode3)) {
17245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17246 }
17247 arg3 = static_cast< int >(val3);
17248 {
17249 PyThreadState* __tstate = wxPyBeginAllowThreads();
17250 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 {
17255 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17256 }
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj = 0;
17265 wxGrid *arg1 = (wxGrid *) 0 ;
17266 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17267 void *argp1 = 0 ;
17268 int res1 = 0 ;
17269 void *argp2 = 0 ;
17270 int res2 = 0 ;
17271 PyObject * obj0 = 0 ;
17272 PyObject * obj1 = 0 ;
17273 char * kwnames[] = {
17274 (char *) "self",(char *) "editor", NULL
17275 };
17276
17277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17279 if (!SWIG_IsOK(res1)) {
17280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17281 }
17282 arg1 = reinterpret_cast< wxGrid * >(argp1);
17283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17284 if (!SWIG_IsOK(res2)) {
17285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17286 }
17287 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17288 {
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 (arg1)->SetDefaultEditor(arg2);
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 resultobj = SWIG_Py_Void();
17295 return resultobj;
17296 fail:
17297 return NULL;
17298 }
17299
17300
17301 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj = 0;
17303 wxGrid *arg1 = (wxGrid *) 0 ;
17304 int arg2 ;
17305 int arg3 ;
17306 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17307 void *argp1 = 0 ;
17308 int res1 = 0 ;
17309 int val2 ;
17310 int ecode2 = 0 ;
17311 int val3 ;
17312 int ecode3 = 0 ;
17313 void *argp4 = 0 ;
17314 int res4 = 0 ;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 PyObject * obj2 = 0 ;
17318 PyObject * obj3 = 0 ;
17319 char * kwnames[] = {
17320 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17321 };
17322
17323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17325 if (!SWIG_IsOK(res1)) {
17326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17327 }
17328 arg1 = reinterpret_cast< wxGrid * >(argp1);
17329 ecode2 = SWIG_AsVal_int(obj1, &val2);
17330 if (!SWIG_IsOK(ecode2)) {
17331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17332 }
17333 arg2 = static_cast< int >(val2);
17334 ecode3 = SWIG_AsVal_int(obj2, &val3);
17335 if (!SWIG_IsOK(ecode3)) {
17336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17337 }
17338 arg3 = static_cast< int >(val3);
17339 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17340 if (!SWIG_IsOK(res4)) {
17341 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17342 }
17343 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17344 {
17345 PyThreadState* __tstate = wxPyBeginAllowThreads();
17346 (arg1)->SetCellEditor(arg2,arg3,arg4);
17347 wxPyEndAllowThreads(__tstate);
17348 if (PyErr_Occurred()) SWIG_fail;
17349 }
17350 resultobj = SWIG_Py_Void();
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 PyObject *resultobj = 0;
17359 wxGrid *arg1 = (wxGrid *) 0 ;
17360 wxGridCellEditor *result = 0 ;
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_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17370 }
17371 arg1 = reinterpret_cast< wxGrid * >(argp1);
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 {
17379 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17380 }
17381 return resultobj;
17382 fail:
17383 return NULL;
17384 }
17385
17386
17387 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17388 PyObject *resultobj = 0;
17389 wxGrid *arg1 = (wxGrid *) 0 ;
17390 int arg2 ;
17391 int arg3 ;
17392 wxGridCellEditor *result = 0 ;
17393 void *argp1 = 0 ;
17394 int res1 = 0 ;
17395 int val2 ;
17396 int ecode2 = 0 ;
17397 int val3 ;
17398 int ecode3 = 0 ;
17399 PyObject * obj0 = 0 ;
17400 PyObject * obj1 = 0 ;
17401 PyObject * obj2 = 0 ;
17402 char * kwnames[] = {
17403 (char *) "self",(char *) "row",(char *) "col", NULL
17404 };
17405
17406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17408 if (!SWIG_IsOK(res1)) {
17409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17410 }
17411 arg1 = reinterpret_cast< wxGrid * >(argp1);
17412 ecode2 = SWIG_AsVal_int(obj1, &val2);
17413 if (!SWIG_IsOK(ecode2)) {
17414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17415 }
17416 arg2 = static_cast< int >(val2);
17417 ecode3 = SWIG_AsVal_int(obj2, &val3);
17418 if (!SWIG_IsOK(ecode3)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17420 }
17421 arg3 = static_cast< int >(val3);
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 {
17429 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17430 }
17431 return resultobj;
17432 fail:
17433 return NULL;
17434 }
17435
17436
17437 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17438 PyObject *resultobj = 0;
17439 wxGrid *arg1 = (wxGrid *) 0 ;
17440 int arg2 ;
17441 int arg3 ;
17442 wxString result;
17443 void *argp1 = 0 ;
17444 int res1 = 0 ;
17445 int val2 ;
17446 int ecode2 = 0 ;
17447 int val3 ;
17448 int ecode3 = 0 ;
17449 PyObject * obj0 = 0 ;
17450 PyObject * obj1 = 0 ;
17451 PyObject * obj2 = 0 ;
17452 char * kwnames[] = {
17453 (char *) "self",(char *) "row",(char *) "col", NULL
17454 };
17455
17456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17458 if (!SWIG_IsOK(res1)) {
17459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17460 }
17461 arg1 = reinterpret_cast< wxGrid * >(argp1);
17462 ecode2 = SWIG_AsVal_int(obj1, &val2);
17463 if (!SWIG_IsOK(ecode2)) {
17464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17465 }
17466 arg2 = static_cast< int >(val2);
17467 ecode3 = SWIG_AsVal_int(obj2, &val3);
17468 if (!SWIG_IsOK(ecode3)) {
17469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17470 }
17471 arg3 = static_cast< int >(val3);
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (arg1)->GetCellValue(arg2,arg3);
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 #if wxUSE_UNICODE
17480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17481 #else
17482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17483 #endif
17484 }
17485 return resultobj;
17486 fail:
17487 return NULL;
17488 }
17489
17490
17491 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17492 PyObject *resultobj = 0;
17493 wxGrid *arg1 = (wxGrid *) 0 ;
17494 int arg2 ;
17495 int arg3 ;
17496 wxString *arg4 = 0 ;
17497 void *argp1 = 0 ;
17498 int res1 = 0 ;
17499 int val2 ;
17500 int ecode2 = 0 ;
17501 int val3 ;
17502 int ecode3 = 0 ;
17503 bool temp4 = false ;
17504 PyObject * obj0 = 0 ;
17505 PyObject * obj1 = 0 ;
17506 PyObject * obj2 = 0 ;
17507 PyObject * obj3 = 0 ;
17508 char * kwnames[] = {
17509 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17510 };
17511
17512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17514 if (!SWIG_IsOK(res1)) {
17515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17516 }
17517 arg1 = reinterpret_cast< wxGrid * >(argp1);
17518 ecode2 = SWIG_AsVal_int(obj1, &val2);
17519 if (!SWIG_IsOK(ecode2)) {
17520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17521 }
17522 arg2 = static_cast< int >(val2);
17523 ecode3 = SWIG_AsVal_int(obj2, &val3);
17524 if (!SWIG_IsOK(ecode3)) {
17525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17526 }
17527 arg3 = static_cast< int >(val3);
17528 {
17529 arg4 = wxString_in_helper(obj3);
17530 if (arg4 == NULL) SWIG_fail;
17531 temp4 = true;
17532 }
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 resultobj = SWIG_Py_Void();
17540 {
17541 if (temp4)
17542 delete arg4;
17543 }
17544 return resultobj;
17545 fail:
17546 {
17547 if (temp4)
17548 delete arg4;
17549 }
17550 return NULL;
17551 }
17552
17553
17554 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj = 0;
17556 wxGrid *arg1 = (wxGrid *) 0 ;
17557 int arg2 ;
17558 int arg3 ;
17559 bool result;
17560 void *argp1 = 0 ;
17561 int res1 = 0 ;
17562 int val2 ;
17563 int ecode2 = 0 ;
17564 int val3 ;
17565 int ecode3 = 0 ;
17566 PyObject * obj0 = 0 ;
17567 PyObject * obj1 = 0 ;
17568 PyObject * obj2 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "self",(char *) "row",(char *) "col", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17577 }
17578 arg1 = reinterpret_cast< wxGrid * >(argp1);
17579 ecode2 = SWIG_AsVal_int(obj1, &val2);
17580 if (!SWIG_IsOK(ecode2)) {
17581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17582 }
17583 arg2 = static_cast< int >(val2);
17584 ecode3 = SWIG_AsVal_int(obj2, &val3);
17585 if (!SWIG_IsOK(ecode3)) {
17586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17587 }
17588 arg3 = static_cast< int >(val3);
17589 {
17590 PyThreadState* __tstate = wxPyBeginAllowThreads();
17591 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 {
17596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17597 }
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj = 0;
17606 wxGrid *arg1 = (wxGrid *) 0 ;
17607 int arg2 ;
17608 int arg3 ;
17609 bool arg4 = (bool) true ;
17610 void *argp1 = 0 ;
17611 int res1 = 0 ;
17612 int val2 ;
17613 int ecode2 = 0 ;
17614 int val3 ;
17615 int ecode3 = 0 ;
17616 bool val4 ;
17617 int ecode4 = 0 ;
17618 PyObject * obj0 = 0 ;
17619 PyObject * obj1 = 0 ;
17620 PyObject * obj2 = 0 ;
17621 PyObject * obj3 = 0 ;
17622 char * kwnames[] = {
17623 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17624 };
17625
17626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17628 if (!SWIG_IsOK(res1)) {
17629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17630 }
17631 arg1 = reinterpret_cast< wxGrid * >(argp1);
17632 ecode2 = SWIG_AsVal_int(obj1, &val2);
17633 if (!SWIG_IsOK(ecode2)) {
17634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17635 }
17636 arg2 = static_cast< int >(val2);
17637 ecode3 = SWIG_AsVal_int(obj2, &val3);
17638 if (!SWIG_IsOK(ecode3)) {
17639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17640 }
17641 arg3 = static_cast< int >(val3);
17642 if (obj3) {
17643 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17644 if (!SWIG_IsOK(ecode4)) {
17645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17646 }
17647 arg4 = static_cast< bool >(val4);
17648 }
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 (arg1)->SetReadOnly(arg2,arg3,arg4);
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 resultobj = SWIG_Py_Void();
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj = 0;
17664 wxGrid *arg1 = (wxGrid *) 0 ;
17665 int arg2 ;
17666 bool arg3 = (bool) false ;
17667 void *argp1 = 0 ;
17668 int res1 = 0 ;
17669 int val2 ;
17670 int ecode2 = 0 ;
17671 bool val3 ;
17672 int ecode3 = 0 ;
17673 PyObject * obj0 = 0 ;
17674 PyObject * obj1 = 0 ;
17675 PyObject * obj2 = 0 ;
17676 char * kwnames[] = {
17677 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17678 };
17679
17680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17682 if (!SWIG_IsOK(res1)) {
17683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17684 }
17685 arg1 = reinterpret_cast< wxGrid * >(argp1);
17686 ecode2 = SWIG_AsVal_int(obj1, &val2);
17687 if (!SWIG_IsOK(ecode2)) {
17688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17689 }
17690 arg2 = static_cast< int >(val2);
17691 if (obj2) {
17692 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17693 if (!SWIG_IsOK(ecode3)) {
17694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17695 }
17696 arg3 = static_cast< bool >(val3);
17697 }
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 (arg1)->SelectRow(arg2,arg3);
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_Py_Void();
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17712 PyObject *resultobj = 0;
17713 wxGrid *arg1 = (wxGrid *) 0 ;
17714 int arg2 ;
17715 bool arg3 = (bool) false ;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 int val2 ;
17719 int ecode2 = 0 ;
17720 bool val3 ;
17721 int ecode3 = 0 ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 PyObject * obj2 = 0 ;
17725 char * kwnames[] = {
17726 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17727 };
17728
17729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17733 }
17734 arg1 = reinterpret_cast< wxGrid * >(argp1);
17735 ecode2 = SWIG_AsVal_int(obj1, &val2);
17736 if (!SWIG_IsOK(ecode2)) {
17737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17738 }
17739 arg2 = static_cast< int >(val2);
17740 if (obj2) {
17741 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17742 if (!SWIG_IsOK(ecode3)) {
17743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17744 }
17745 arg3 = static_cast< bool >(val3);
17746 }
17747 {
17748 PyThreadState* __tstate = wxPyBeginAllowThreads();
17749 (arg1)->SelectCol(arg2,arg3);
17750 wxPyEndAllowThreads(__tstate);
17751 if (PyErr_Occurred()) SWIG_fail;
17752 }
17753 resultobj = SWIG_Py_Void();
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = 0;
17762 wxGrid *arg1 = (wxGrid *) 0 ;
17763 int arg2 ;
17764 int arg3 ;
17765 int arg4 ;
17766 int arg5 ;
17767 bool arg6 = (bool) false ;
17768 void *argp1 = 0 ;
17769 int res1 = 0 ;
17770 int val2 ;
17771 int ecode2 = 0 ;
17772 int val3 ;
17773 int ecode3 = 0 ;
17774 int val4 ;
17775 int ecode4 = 0 ;
17776 int val5 ;
17777 int ecode5 = 0 ;
17778 bool val6 ;
17779 int ecode6 = 0 ;
17780 PyObject * obj0 = 0 ;
17781 PyObject * obj1 = 0 ;
17782 PyObject * obj2 = 0 ;
17783 PyObject * obj3 = 0 ;
17784 PyObject * obj4 = 0 ;
17785 PyObject * obj5 = 0 ;
17786 char * kwnames[] = {
17787 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17788 };
17789
17790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17792 if (!SWIG_IsOK(res1)) {
17793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17794 }
17795 arg1 = reinterpret_cast< wxGrid * >(argp1);
17796 ecode2 = SWIG_AsVal_int(obj1, &val2);
17797 if (!SWIG_IsOK(ecode2)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17799 }
17800 arg2 = static_cast< int >(val2);
17801 ecode3 = SWIG_AsVal_int(obj2, &val3);
17802 if (!SWIG_IsOK(ecode3)) {
17803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17804 }
17805 arg3 = static_cast< int >(val3);
17806 ecode4 = SWIG_AsVal_int(obj3, &val4);
17807 if (!SWIG_IsOK(ecode4)) {
17808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17809 }
17810 arg4 = static_cast< int >(val4);
17811 ecode5 = SWIG_AsVal_int(obj4, &val5);
17812 if (!SWIG_IsOK(ecode5)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17814 }
17815 arg5 = static_cast< int >(val5);
17816 if (obj5) {
17817 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17818 if (!SWIG_IsOK(ecode6)) {
17819 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17820 }
17821 arg6 = static_cast< bool >(val6);
17822 }
17823 {
17824 PyThreadState* __tstate = wxPyBeginAllowThreads();
17825 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 resultobj = SWIG_Py_Void();
17830 return resultobj;
17831 fail:
17832 return NULL;
17833 }
17834
17835
17836 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17837 PyObject *resultobj = 0;
17838 wxGrid *arg1 = (wxGrid *) 0 ;
17839 void *argp1 = 0 ;
17840 int res1 = 0 ;
17841 PyObject *swig_obj[1] ;
17842
17843 if (!args) SWIG_fail;
17844 swig_obj[0] = args;
17845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17846 if (!SWIG_IsOK(res1)) {
17847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17848 }
17849 arg1 = reinterpret_cast< wxGrid * >(argp1);
17850 {
17851 PyThreadState* __tstate = wxPyBeginAllowThreads();
17852 (arg1)->SelectAll();
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 resultobj = SWIG_Py_Void();
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17864 PyObject *resultobj = 0;
17865 wxGrid *arg1 = (wxGrid *) 0 ;
17866 bool result;
17867 void *argp1 = 0 ;
17868 int res1 = 0 ;
17869 PyObject *swig_obj[1] ;
17870
17871 if (!args) SWIG_fail;
17872 swig_obj[0] = args;
17873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17874 if (!SWIG_IsOK(res1)) {
17875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17876 }
17877 arg1 = reinterpret_cast< wxGrid * >(argp1);
17878 {
17879 PyThreadState* __tstate = wxPyBeginAllowThreads();
17880 result = (bool)(arg1)->IsSelection();
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 {
17885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17886 }
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17894 PyObject *resultobj = 0;
17895 wxGrid *arg1 = (wxGrid *) 0 ;
17896 void *argp1 = 0 ;
17897 int res1 = 0 ;
17898 PyObject *swig_obj[1] ;
17899
17900 if (!args) SWIG_fail;
17901 swig_obj[0] = args;
17902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17903 if (!SWIG_IsOK(res1)) {
17904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17905 }
17906 arg1 = reinterpret_cast< wxGrid * >(argp1);
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 (arg1)->ClearSelection();
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 resultobj = SWIG_Py_Void();
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj = 0;
17922 wxGrid *arg1 = (wxGrid *) 0 ;
17923 int arg2 ;
17924 int arg3 ;
17925 bool result;
17926 void *argp1 = 0 ;
17927 int res1 = 0 ;
17928 int val2 ;
17929 int ecode2 = 0 ;
17930 int val3 ;
17931 int ecode3 = 0 ;
17932 PyObject * obj0 = 0 ;
17933 PyObject * obj1 = 0 ;
17934 PyObject * obj2 = 0 ;
17935 char * kwnames[] = {
17936 (char *) "self",(char *) "row",(char *) "col", NULL
17937 };
17938
17939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17941 if (!SWIG_IsOK(res1)) {
17942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17943 }
17944 arg1 = reinterpret_cast< wxGrid * >(argp1);
17945 ecode2 = SWIG_AsVal_int(obj1, &val2);
17946 if (!SWIG_IsOK(ecode2)) {
17947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17948 }
17949 arg2 = static_cast< int >(val2);
17950 ecode3 = SWIG_AsVal_int(obj2, &val3);
17951 if (!SWIG_IsOK(ecode3)) {
17952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17953 }
17954 arg3 = static_cast< int >(val3);
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17958 wxPyEndAllowThreads(__tstate);
17959 if (PyErr_Occurred()) SWIG_fail;
17960 }
17961 {
17962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17963 }
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17971 PyObject *resultobj = 0;
17972 wxGrid *arg1 = (wxGrid *) 0 ;
17973 wxGridCellCoordsArray result;
17974 void *argp1 = 0 ;
17975 int res1 = 0 ;
17976 PyObject *swig_obj[1] ;
17977
17978 if (!args) SWIG_fail;
17979 swig_obj[0] = args;
17980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17981 if (!SWIG_IsOK(res1)) {
17982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17983 }
17984 arg1 = reinterpret_cast< wxGrid * >(argp1);
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = ((wxGrid const *)arg1)->GetSelectedCells();
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = wxGridCellCoordsArray_helper(result);
17993 }
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18001 PyObject *resultobj = 0;
18002 wxGrid *arg1 = (wxGrid *) 0 ;
18003 wxGridCellCoordsArray result;
18004 void *argp1 = 0 ;
18005 int res1 = 0 ;
18006 PyObject *swig_obj[1] ;
18007
18008 if (!args) SWIG_fail;
18009 swig_obj[0] = args;
18010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18011 if (!SWIG_IsOK(res1)) {
18012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18013 }
18014 arg1 = reinterpret_cast< wxGrid * >(argp1);
18015 {
18016 PyThreadState* __tstate = wxPyBeginAllowThreads();
18017 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 resultobj = wxGridCellCoordsArray_helper(result);
18023 }
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18031 PyObject *resultobj = 0;
18032 wxGrid *arg1 = (wxGrid *) 0 ;
18033 wxGridCellCoordsArray result;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 PyObject *swig_obj[1] ;
18037
18038 if (!args) SWIG_fail;
18039 swig_obj[0] = args;
18040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18041 if (!SWIG_IsOK(res1)) {
18042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18043 }
18044 arg1 = reinterpret_cast< wxGrid * >(argp1);
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = wxGridCellCoordsArray_helper(result);
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 PyObject *resultobj = 0;
18062 wxGrid *arg1 = (wxGrid *) 0 ;
18063 wxArrayInt result;
18064 void *argp1 = 0 ;
18065 int res1 = 0 ;
18066 PyObject *swig_obj[1] ;
18067
18068 if (!args) SWIG_fail;
18069 swig_obj[0] = args;
18070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18073 }
18074 arg1 = reinterpret_cast< wxGrid * >(argp1);
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = ((wxGrid const *)arg1)->GetSelectedRows();
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 {
18082 resultobj = wxArrayInt2PyList_helper(result);
18083 }
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *resultobj = 0;
18092 wxGrid *arg1 = (wxGrid *) 0 ;
18093 wxArrayInt result;
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_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18103 }
18104 arg1 = reinterpret_cast< wxGrid * >(argp1);
18105 {
18106 PyThreadState* __tstate = wxPyBeginAllowThreads();
18107 result = ((wxGrid const *)arg1)->GetSelectedCols();
18108 wxPyEndAllowThreads(__tstate);
18109 if (PyErr_Occurred()) SWIG_fail;
18110 }
18111 {
18112 resultobj = wxArrayInt2PyList_helper(result);
18113 }
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18121 PyObject *resultobj = 0;
18122 wxGrid *arg1 = (wxGrid *) 0 ;
18123 int arg2 ;
18124 void *argp1 = 0 ;
18125 int res1 = 0 ;
18126 int val2 ;
18127 int ecode2 = 0 ;
18128 PyObject * obj0 = 0 ;
18129 PyObject * obj1 = 0 ;
18130 char * kwnames[] = {
18131 (char *) "self",(char *) "row", NULL
18132 };
18133
18134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18136 if (!SWIG_IsOK(res1)) {
18137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18138 }
18139 arg1 = reinterpret_cast< wxGrid * >(argp1);
18140 ecode2 = SWIG_AsVal_int(obj1, &val2);
18141 if (!SWIG_IsOK(ecode2)) {
18142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18143 }
18144 arg2 = static_cast< int >(val2);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 (arg1)->DeselectRow(arg2);
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = SWIG_Py_Void();
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj = 0;
18160 wxGrid *arg1 = (wxGrid *) 0 ;
18161 int arg2 ;
18162 void *argp1 = 0 ;
18163 int res1 = 0 ;
18164 int val2 ;
18165 int ecode2 = 0 ;
18166 PyObject * obj0 = 0 ;
18167 PyObject * obj1 = 0 ;
18168 char * kwnames[] = {
18169 (char *) "self",(char *) "col", NULL
18170 };
18171
18172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18176 }
18177 arg1 = reinterpret_cast< wxGrid * >(argp1);
18178 ecode2 = SWIG_AsVal_int(obj1, &val2);
18179 if (!SWIG_IsOK(ecode2)) {
18180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18181 }
18182 arg2 = static_cast< int >(val2);
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 (arg1)->DeselectCol(arg2);
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_Py_Void();
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj = 0;
18198 wxGrid *arg1 = (wxGrid *) 0 ;
18199 int arg2 ;
18200 int arg3 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 int val2 ;
18204 int ecode2 = 0 ;
18205 int val3 ;
18206 int ecode3 = 0 ;
18207 PyObject * obj0 = 0 ;
18208 PyObject * obj1 = 0 ;
18209 PyObject * obj2 = 0 ;
18210 char * kwnames[] = {
18211 (char *) "self",(char *) "row",(char *) "col", NULL
18212 };
18213
18214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18216 if (!SWIG_IsOK(res1)) {
18217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18218 }
18219 arg1 = reinterpret_cast< wxGrid * >(argp1);
18220 ecode2 = SWIG_AsVal_int(obj1, &val2);
18221 if (!SWIG_IsOK(ecode2)) {
18222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18223 }
18224 arg2 = static_cast< int >(val2);
18225 ecode3 = SWIG_AsVal_int(obj2, &val3);
18226 if (!SWIG_IsOK(ecode3)) {
18227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18228 }
18229 arg3 = static_cast< int >(val3);
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 (arg1)->DeselectCell(arg2,arg3);
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 resultobj = SWIG_Py_Void();
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj = 0;
18245 wxGrid *arg1 = (wxGrid *) 0 ;
18246 wxGridCellCoords *arg2 = 0 ;
18247 wxGridCellCoords *arg3 = 0 ;
18248 wxRect result;
18249 void *argp1 = 0 ;
18250 int res1 = 0 ;
18251 wxGridCellCoords temp2 ;
18252 wxGridCellCoords temp3 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 PyObject * obj2 = 0 ;
18256 char * kwnames[] = {
18257 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18258 };
18259
18260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18262 if (!SWIG_IsOK(res1)) {
18263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18264 }
18265 arg1 = reinterpret_cast< wxGrid * >(argp1);
18266 {
18267 arg2 = &temp2;
18268 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18269 }
18270 {
18271 arg3 = &temp3;
18272 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18273 }
18274 {
18275 PyThreadState* __tstate = wxPyBeginAllowThreads();
18276 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18277 wxPyEndAllowThreads(__tstate);
18278 if (PyErr_Occurred()) SWIG_fail;
18279 }
18280 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18288 PyObject *resultobj = 0;
18289 wxGrid *arg1 = (wxGrid *) 0 ;
18290 wxColour result;
18291 void *argp1 = 0 ;
18292 int res1 = 0 ;
18293 PyObject *swig_obj[1] ;
18294
18295 if (!args) SWIG_fail;
18296 swig_obj[0] = args;
18297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18298 if (!SWIG_IsOK(res1)) {
18299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18300 }
18301 arg1 = reinterpret_cast< wxGrid * >(argp1);
18302 {
18303 PyThreadState* __tstate = wxPyBeginAllowThreads();
18304 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18316 PyObject *resultobj = 0;
18317 wxGrid *arg1 = (wxGrid *) 0 ;
18318 wxColour result;
18319 void *argp1 = 0 ;
18320 int res1 = 0 ;
18321 PyObject *swig_obj[1] ;
18322
18323 if (!args) SWIG_fail;
18324 swig_obj[0] = args;
18325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18326 if (!SWIG_IsOK(res1)) {
18327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18328 }
18329 arg1 = reinterpret_cast< wxGrid * >(argp1);
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18344 PyObject *resultobj = 0;
18345 wxGrid *arg1 = (wxGrid *) 0 ;
18346 wxColour *arg2 = 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 wxColour temp2 ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 char * kwnames[] = {
18353 (char *) "self",(char *) "c", NULL
18354 };
18355
18356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18360 }
18361 arg1 = reinterpret_cast< wxGrid * >(argp1);
18362 {
18363 arg2 = &temp2;
18364 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18365 }
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = SWIG_Py_Void();
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18380 PyObject *resultobj = 0;
18381 wxGrid *arg1 = (wxGrid *) 0 ;
18382 wxColour *arg2 = 0 ;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 wxColour temp2 ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 char * kwnames[] = {
18389 (char *) "self",(char *) "c", NULL
18390 };
18391
18392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18394 if (!SWIG_IsOK(res1)) {
18395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18396 }
18397 arg1 = reinterpret_cast< wxGrid * >(argp1);
18398 {
18399 arg2 = &temp2;
18400 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18401 }
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18405 wxPyEndAllowThreads(__tstate);
18406 if (PyErr_Occurred()) SWIG_fail;
18407 }
18408 resultobj = SWIG_Py_Void();
18409 return resultobj;
18410 fail:
18411 return NULL;
18412 }
18413
18414
18415 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18416 PyObject *resultobj = 0;
18417 wxGrid *arg1 = (wxGrid *) 0 ;
18418 wxString *arg2 = 0 ;
18419 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18420 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18421 void *argp1 = 0 ;
18422 int res1 = 0 ;
18423 bool temp2 = false ;
18424 void *argp3 = 0 ;
18425 int res3 = 0 ;
18426 void *argp4 = 0 ;
18427 int res4 = 0 ;
18428 PyObject * obj0 = 0 ;
18429 PyObject * obj1 = 0 ;
18430 PyObject * obj2 = 0 ;
18431 PyObject * obj3 = 0 ;
18432 char * kwnames[] = {
18433 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18434 };
18435
18436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18438 if (!SWIG_IsOK(res1)) {
18439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18440 }
18441 arg1 = reinterpret_cast< wxGrid * >(argp1);
18442 {
18443 arg2 = wxString_in_helper(obj1);
18444 if (arg2 == NULL) SWIG_fail;
18445 temp2 = true;
18446 }
18447 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18448 if (!SWIG_IsOK(res3)) {
18449 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18450 }
18451 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18452 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18453 if (!SWIG_IsOK(res4)) {
18454 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18455 }
18456 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 resultobj = SWIG_Py_Void();
18464 {
18465 if (temp2)
18466 delete arg2;
18467 }
18468 return resultobj;
18469 fail:
18470 {
18471 if (temp2)
18472 delete arg2;
18473 }
18474 return NULL;
18475 }
18476
18477
18478 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj = 0;
18480 wxGrid *arg1 = (wxGrid *) 0 ;
18481 int arg2 ;
18482 int arg3 ;
18483 wxGridCellEditor *result = 0 ;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 int val2 ;
18487 int ecode2 = 0 ;
18488 int val3 ;
18489 int ecode3 = 0 ;
18490 PyObject * obj0 = 0 ;
18491 PyObject * obj1 = 0 ;
18492 PyObject * obj2 = 0 ;
18493 char * kwnames[] = {
18494 (char *) "self",(char *) "row",(char *) "col", NULL
18495 };
18496
18497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18499 if (!SWIG_IsOK(res1)) {
18500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18501 }
18502 arg1 = reinterpret_cast< wxGrid * >(argp1);
18503 ecode2 = SWIG_AsVal_int(obj1, &val2);
18504 if (!SWIG_IsOK(ecode2)) {
18505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18506 }
18507 arg2 = static_cast< int >(val2);
18508 ecode3 = SWIG_AsVal_int(obj2, &val3);
18509 if (!SWIG_IsOK(ecode3)) {
18510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18511 }
18512 arg3 = static_cast< int >(val3);
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 {
18520 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18521 }
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj = 0;
18530 wxGrid *arg1 = (wxGrid *) 0 ;
18531 int arg2 ;
18532 int arg3 ;
18533 wxGridCellRenderer *result = 0 ;
18534 void *argp1 = 0 ;
18535 int res1 = 0 ;
18536 int val2 ;
18537 int ecode2 = 0 ;
18538 int val3 ;
18539 int ecode3 = 0 ;
18540 PyObject * obj0 = 0 ;
18541 PyObject * obj1 = 0 ;
18542 PyObject * obj2 = 0 ;
18543 char * kwnames[] = {
18544 (char *) "self",(char *) "row",(char *) "col", NULL
18545 };
18546
18547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18549 if (!SWIG_IsOK(res1)) {
18550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18551 }
18552 arg1 = reinterpret_cast< wxGrid * >(argp1);
18553 ecode2 = SWIG_AsVal_int(obj1, &val2);
18554 if (!SWIG_IsOK(ecode2)) {
18555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18556 }
18557 arg2 = static_cast< int >(val2);
18558 ecode3 = SWIG_AsVal_int(obj2, &val3);
18559 if (!SWIG_IsOK(ecode3)) {
18560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18561 }
18562 arg3 = static_cast< int >(val3);
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18566 wxPyEndAllowThreads(__tstate);
18567 if (PyErr_Occurred()) SWIG_fail;
18568 }
18569 {
18570 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18571 }
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18579 PyObject *resultobj = 0;
18580 wxGrid *arg1 = (wxGrid *) 0 ;
18581 wxString *arg2 = 0 ;
18582 wxGridCellEditor *result = 0 ;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 bool temp2 = false ;
18586 PyObject * obj0 = 0 ;
18587 PyObject * obj1 = 0 ;
18588 char * kwnames[] = {
18589 (char *) "self",(char *) "typeName", NULL
18590 };
18591
18592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18594 if (!SWIG_IsOK(res1)) {
18595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18596 }
18597 arg1 = reinterpret_cast< wxGrid * >(argp1);
18598 {
18599 arg2 = wxString_in_helper(obj1);
18600 if (arg2 == NULL) SWIG_fail;
18601 temp2 = true;
18602 }
18603 {
18604 PyThreadState* __tstate = wxPyBeginAllowThreads();
18605 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 {
18610 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18611 }
18612 {
18613 if (temp2)
18614 delete arg2;
18615 }
18616 return resultobj;
18617 fail:
18618 {
18619 if (temp2)
18620 delete arg2;
18621 }
18622 return NULL;
18623 }
18624
18625
18626 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj = 0;
18628 wxGrid *arg1 = (wxGrid *) 0 ;
18629 wxString *arg2 = 0 ;
18630 wxGridCellRenderer *result = 0 ;
18631 void *argp1 = 0 ;
18632 int res1 = 0 ;
18633 bool temp2 = false ;
18634 PyObject * obj0 = 0 ;
18635 PyObject * obj1 = 0 ;
18636 char * kwnames[] = {
18637 (char *) "self",(char *) "typeName", NULL
18638 };
18639
18640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18642 if (!SWIG_IsOK(res1)) {
18643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18644 }
18645 arg1 = reinterpret_cast< wxGrid * >(argp1);
18646 {
18647 arg2 = wxString_in_helper(obj1);
18648 if (arg2 == NULL) SWIG_fail;
18649 temp2 = true;
18650 }
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18659 }
18660 {
18661 if (temp2)
18662 delete arg2;
18663 }
18664 return resultobj;
18665 fail:
18666 {
18667 if (temp2)
18668 delete arg2;
18669 }
18670 return NULL;
18671 }
18672
18673
18674 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj = 0;
18676 wxGrid *arg1 = (wxGrid *) 0 ;
18677 int arg2 ;
18678 int arg3 ;
18679 void *argp1 = 0 ;
18680 int res1 = 0 ;
18681 int val2 ;
18682 int ecode2 = 0 ;
18683 int val3 ;
18684 int ecode3 = 0 ;
18685 PyObject * obj0 = 0 ;
18686 PyObject * obj1 = 0 ;
18687 PyObject * obj2 = 0 ;
18688 char * kwnames[] = {
18689 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18690 };
18691
18692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18694 if (!SWIG_IsOK(res1)) {
18695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18696 }
18697 arg1 = reinterpret_cast< wxGrid * >(argp1);
18698 ecode2 = SWIG_AsVal_int(obj1, &val2);
18699 if (!SWIG_IsOK(ecode2)) {
18700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18701 }
18702 arg2 = static_cast< int >(val2);
18703 ecode3 = SWIG_AsVal_int(obj2, &val3);
18704 if (!SWIG_IsOK(ecode3)) {
18705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18706 }
18707 arg3 = static_cast< int >(val3);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 (arg1)->SetMargins(arg2,arg3);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_Py_Void();
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *resultobj = 0;
18723 wxGrid *arg1 = (wxGrid *) 0 ;
18724 wxWindow *result = 0 ;
18725 void *argp1 = 0 ;
18726 int res1 = 0 ;
18727 PyObject *swig_obj[1] ;
18728
18729 if (!args) SWIG_fail;
18730 swig_obj[0] = args;
18731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18732 if (!SWIG_IsOK(res1)) {
18733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18734 }
18735 arg1 = reinterpret_cast< wxGrid * >(argp1);
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (wxWindow *)(arg1)->GetGridWindow();
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 {
18743 resultobj = wxPyMake_wxObject(result, 0);
18744 }
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 PyObject *resultobj = 0;
18753 wxGrid *arg1 = (wxGrid *) 0 ;
18754 wxWindow *result = 0 ;
18755 void *argp1 = 0 ;
18756 int res1 = 0 ;
18757 PyObject *swig_obj[1] ;
18758
18759 if (!args) SWIG_fail;
18760 swig_obj[0] = args;
18761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18764 }
18765 arg1 = reinterpret_cast< wxGrid * >(argp1);
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 {
18773 resultobj = wxPyMake_wxObject(result, 0);
18774 }
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18782 PyObject *resultobj = 0;
18783 wxGrid *arg1 = (wxGrid *) 0 ;
18784 wxWindow *result = 0 ;
18785 void *argp1 = 0 ;
18786 int res1 = 0 ;
18787 PyObject *swig_obj[1] ;
18788
18789 if (!args) SWIG_fail;
18790 swig_obj[0] = args;
18791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18794 }
18795 arg1 = reinterpret_cast< wxGrid * >(argp1);
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 {
18803 resultobj = wxPyMake_wxObject(result, 0);
18804 }
18805 return resultobj;
18806 fail:
18807 return NULL;
18808 }
18809
18810
18811 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18812 PyObject *resultobj = 0;
18813 wxGrid *arg1 = (wxGrid *) 0 ;
18814 wxWindow *result = 0 ;
18815 void *argp1 = 0 ;
18816 int res1 = 0 ;
18817 PyObject *swig_obj[1] ;
18818
18819 if (!args) SWIG_fail;
18820 swig_obj[0] = args;
18821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18822 if (!SWIG_IsOK(res1)) {
18823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18824 }
18825 arg1 = reinterpret_cast< wxGrid * >(argp1);
18826 {
18827 PyThreadState* __tstate = wxPyBeginAllowThreads();
18828 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18829 wxPyEndAllowThreads(__tstate);
18830 if (PyErr_Occurred()) SWIG_fail;
18831 }
18832 {
18833 resultobj = wxPyMake_wxObject(result, 0);
18834 }
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18842 PyObject *resultobj = 0;
18843 wxGrid *arg1 = (wxGrid *) 0 ;
18844 int arg2 ;
18845 void *argp1 = 0 ;
18846 int res1 = 0 ;
18847 int val2 ;
18848 int ecode2 = 0 ;
18849 PyObject * obj0 = 0 ;
18850 PyObject * obj1 = 0 ;
18851 char * kwnames[] = {
18852 (char *) "self",(char *) "x", NULL
18853 };
18854
18855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18857 if (!SWIG_IsOK(res1)) {
18858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18859 }
18860 arg1 = reinterpret_cast< wxGrid * >(argp1);
18861 ecode2 = SWIG_AsVal_int(obj1, &val2);
18862 if (!SWIG_IsOK(ecode2)) {
18863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18864 }
18865 arg2 = static_cast< int >(val2);
18866 {
18867 PyThreadState* __tstate = wxPyBeginAllowThreads();
18868 (arg1)->SetScrollLineX(arg2);
18869 wxPyEndAllowThreads(__tstate);
18870 if (PyErr_Occurred()) SWIG_fail;
18871 }
18872 resultobj = SWIG_Py_Void();
18873 return resultobj;
18874 fail:
18875 return NULL;
18876 }
18877
18878
18879 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18880 PyObject *resultobj = 0;
18881 wxGrid *arg1 = (wxGrid *) 0 ;
18882 int arg2 ;
18883 void *argp1 = 0 ;
18884 int res1 = 0 ;
18885 int val2 ;
18886 int ecode2 = 0 ;
18887 PyObject * obj0 = 0 ;
18888 PyObject * obj1 = 0 ;
18889 char * kwnames[] = {
18890 (char *) "self",(char *) "y", NULL
18891 };
18892
18893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18895 if (!SWIG_IsOK(res1)) {
18896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18897 }
18898 arg1 = reinterpret_cast< wxGrid * >(argp1);
18899 ecode2 = SWIG_AsVal_int(obj1, &val2);
18900 if (!SWIG_IsOK(ecode2)) {
18901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18902 }
18903 arg2 = static_cast< int >(val2);
18904 {
18905 PyThreadState* __tstate = wxPyBeginAllowThreads();
18906 (arg1)->SetScrollLineY(arg2);
18907 wxPyEndAllowThreads(__tstate);
18908 if (PyErr_Occurred()) SWIG_fail;
18909 }
18910 resultobj = SWIG_Py_Void();
18911 return resultobj;
18912 fail:
18913 return NULL;
18914 }
18915
18916
18917 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18918 PyObject *resultobj = 0;
18919 wxGrid *arg1 = (wxGrid *) 0 ;
18920 int result;
18921 void *argp1 = 0 ;
18922 int res1 = 0 ;
18923 PyObject *swig_obj[1] ;
18924
18925 if (!args) SWIG_fail;
18926 swig_obj[0] = args;
18927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18928 if (!SWIG_IsOK(res1)) {
18929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18930 }
18931 arg1 = reinterpret_cast< wxGrid * >(argp1);
18932 {
18933 PyThreadState* __tstate = wxPyBeginAllowThreads();
18934 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18935 wxPyEndAllowThreads(__tstate);
18936 if (PyErr_Occurred()) SWIG_fail;
18937 }
18938 resultobj = SWIG_From_int(static_cast< int >(result));
18939 return resultobj;
18940 fail:
18941 return NULL;
18942 }
18943
18944
18945 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18946 PyObject *resultobj = 0;
18947 wxGrid *arg1 = (wxGrid *) 0 ;
18948 int result;
18949 void *argp1 = 0 ;
18950 int res1 = 0 ;
18951 PyObject *swig_obj[1] ;
18952
18953 if (!args) SWIG_fail;
18954 swig_obj[0] = args;
18955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18956 if (!SWIG_IsOK(res1)) {
18957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18958 }
18959 arg1 = reinterpret_cast< wxGrid * >(argp1);
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_From_int(static_cast< int >(result));
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj = 0;
18975 wxGrid *arg1 = (wxGrid *) 0 ;
18976 int arg2 ;
18977 int result;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 int val2 ;
18981 int ecode2 = 0 ;
18982 PyObject * obj0 = 0 ;
18983 PyObject * obj1 = 0 ;
18984 char * kwnames[] = {
18985 (char *) "self",(char *) "x", NULL
18986 };
18987
18988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18992 }
18993 arg1 = reinterpret_cast< wxGrid * >(argp1);
18994 ecode2 = SWIG_AsVal_int(obj1, &val2);
18995 if (!SWIG_IsOK(ecode2)) {
18996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18997 }
18998 arg2 = static_cast< int >(val2);
18999 {
19000 PyThreadState* __tstate = wxPyBeginAllowThreads();
19001 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_From_int(static_cast< int >(result));
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxGrid *arg1 = (wxGrid *) 0 ;
19015 int arg2 ;
19016 int result;
19017 void *argp1 = 0 ;
19018 int res1 = 0 ;
19019 int val2 ;
19020 int ecode2 = 0 ;
19021 PyObject * obj0 = 0 ;
19022 PyObject * obj1 = 0 ;
19023 char * kwnames[] = {
19024 (char *) "self",(char *) "y", NULL
19025 };
19026
19027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19029 if (!SWIG_IsOK(res1)) {
19030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19031 }
19032 arg1 = reinterpret_cast< wxGrid * >(argp1);
19033 ecode2 = SWIG_AsVal_int(obj1, &val2);
19034 if (!SWIG_IsOK(ecode2)) {
19035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19036 }
19037 arg2 = static_cast< int >(val2);
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 resultobj = SWIG_From_int(static_cast< int >(result));
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj = 0;
19053 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19054 SwigValueWrapper<wxVisualAttributes > result;
19055 int val1 ;
19056 int ecode1 = 0 ;
19057 PyObject * obj0 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "variant", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19063 if (obj0) {
19064 ecode1 = SWIG_AsVal_int(obj0, &val1);
19065 if (!SWIG_IsOK(ecode1)) {
19066 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19067 }
19068 arg1 = static_cast< wxWindowVariant >(val1);
19069 }
19070 {
19071 if (!wxPyCheckForApp()) SWIG_fail;
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 result = wxGrid::GetClassDefaultAttributes(arg1);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19085 PyObject *obj;
19086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19087 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19088 return SWIG_Py_Void();
19089 }
19090
19091 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092 return SWIG_Python_InitShadowInstance(args);
19093 }
19094
19095 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj = 0;
19097 int arg1 ;
19098 wxEventType arg2 ;
19099 wxGrid *arg3 = (wxGrid *) 0 ;
19100 int arg4 = (int) -1 ;
19101 int arg5 = (int) -1 ;
19102 int arg6 = (int) -1 ;
19103 int arg7 = (int) -1 ;
19104 bool arg8 = (bool) true ;
19105 bool arg9 = (bool) false ;
19106 bool arg10 = (bool) false ;
19107 bool arg11 = (bool) false ;
19108 bool arg12 = (bool) false ;
19109 wxGridEvent *result = 0 ;
19110 int val1 ;
19111 int ecode1 = 0 ;
19112 int val2 ;
19113 int ecode2 = 0 ;
19114 void *argp3 = 0 ;
19115 int res3 = 0 ;
19116 int val4 ;
19117 int ecode4 = 0 ;
19118 int val5 ;
19119 int ecode5 = 0 ;
19120 int val6 ;
19121 int ecode6 = 0 ;
19122 int val7 ;
19123 int ecode7 = 0 ;
19124 bool val8 ;
19125 int ecode8 = 0 ;
19126 bool val9 ;
19127 int ecode9 = 0 ;
19128 bool val10 ;
19129 int ecode10 = 0 ;
19130 bool val11 ;
19131 int ecode11 = 0 ;
19132 bool val12 ;
19133 int ecode12 = 0 ;
19134 PyObject * obj0 = 0 ;
19135 PyObject * obj1 = 0 ;
19136 PyObject * obj2 = 0 ;
19137 PyObject * obj3 = 0 ;
19138 PyObject * obj4 = 0 ;
19139 PyObject * obj5 = 0 ;
19140 PyObject * obj6 = 0 ;
19141 PyObject * obj7 = 0 ;
19142 PyObject * obj8 = 0 ;
19143 PyObject * obj9 = 0 ;
19144 PyObject * obj10 = 0 ;
19145 PyObject * obj11 = 0 ;
19146 char * kwnames[] = {
19147 (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
19148 };
19149
19150 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;
19151 ecode1 = SWIG_AsVal_int(obj0, &val1);
19152 if (!SWIG_IsOK(ecode1)) {
19153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19154 }
19155 arg1 = static_cast< int >(val1);
19156 ecode2 = SWIG_AsVal_int(obj1, &val2);
19157 if (!SWIG_IsOK(ecode2)) {
19158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19159 }
19160 arg2 = static_cast< wxEventType >(val2);
19161 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19162 if (!SWIG_IsOK(res3)) {
19163 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19164 }
19165 arg3 = reinterpret_cast< wxGrid * >(argp3);
19166 if (obj3) {
19167 ecode4 = SWIG_AsVal_int(obj3, &val4);
19168 if (!SWIG_IsOK(ecode4)) {
19169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19170 }
19171 arg4 = static_cast< int >(val4);
19172 }
19173 if (obj4) {
19174 ecode5 = SWIG_AsVal_int(obj4, &val5);
19175 if (!SWIG_IsOK(ecode5)) {
19176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19177 }
19178 arg5 = static_cast< int >(val5);
19179 }
19180 if (obj5) {
19181 ecode6 = SWIG_AsVal_int(obj5, &val6);
19182 if (!SWIG_IsOK(ecode6)) {
19183 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19184 }
19185 arg6 = static_cast< int >(val6);
19186 }
19187 if (obj6) {
19188 ecode7 = SWIG_AsVal_int(obj6, &val7);
19189 if (!SWIG_IsOK(ecode7)) {
19190 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19191 }
19192 arg7 = static_cast< int >(val7);
19193 }
19194 if (obj7) {
19195 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19196 if (!SWIG_IsOK(ecode8)) {
19197 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19198 }
19199 arg8 = static_cast< bool >(val8);
19200 }
19201 if (obj8) {
19202 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19203 if (!SWIG_IsOK(ecode9)) {
19204 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19205 }
19206 arg9 = static_cast< bool >(val9);
19207 }
19208 if (obj9) {
19209 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19210 if (!SWIG_IsOK(ecode10)) {
19211 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19212 }
19213 arg10 = static_cast< bool >(val10);
19214 }
19215 if (obj10) {
19216 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19217 if (!SWIG_IsOK(ecode11)) {
19218 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19219 }
19220 arg11 = static_cast< bool >(val11);
19221 }
19222 if (obj11) {
19223 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19224 if (!SWIG_IsOK(ecode12)) {
19225 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19226 }
19227 arg12 = static_cast< bool >(val12);
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19243 PyObject *resultobj = 0;
19244 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19245 int result;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 PyObject *swig_obj[1] ;
19249
19250 if (!args) SWIG_fail;
19251 swig_obj[0] = args;
19252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19253 if (!SWIG_IsOK(res1)) {
19254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19255 }
19256 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 result = (int)(arg1)->GetRow();
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 resultobj = SWIG_From_int(static_cast< int >(result));
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19271 PyObject *resultobj = 0;
19272 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19273 int result;
19274 void *argp1 = 0 ;
19275 int res1 = 0 ;
19276 PyObject *swig_obj[1] ;
19277
19278 if (!args) SWIG_fail;
19279 swig_obj[0] = args;
19280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19281 if (!SWIG_IsOK(res1)) {
19282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19283 }
19284 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 result = (int)(arg1)->GetCol();
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 resultobj = SWIG_From_int(static_cast< int >(result));
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19299 PyObject *resultobj = 0;
19300 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19301 wxPoint result;
19302 void *argp1 = 0 ;
19303 int res1 = 0 ;
19304 PyObject *swig_obj[1] ;
19305
19306 if (!args) SWIG_fail;
19307 swig_obj[0] = args;
19308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19309 if (!SWIG_IsOK(res1)) {
19310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19311 }
19312 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (arg1)->GetPosition();
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19327 PyObject *resultobj = 0;
19328 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19329 bool result;
19330 void *argp1 = 0 ;
19331 int res1 = 0 ;
19332 PyObject *swig_obj[1] ;
19333
19334 if (!args) SWIG_fail;
19335 swig_obj[0] = args;
19336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19337 if (!SWIG_IsOK(res1)) {
19338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19339 }
19340 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = (bool)(arg1)->Selecting();
19344 wxPyEndAllowThreads(__tstate);
19345 if (PyErr_Occurred()) SWIG_fail;
19346 }
19347 {
19348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19349 }
19350 return resultobj;
19351 fail:
19352 return NULL;
19353 }
19354
19355
19356 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19357 PyObject *resultobj = 0;
19358 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19359 bool result;
19360 void *argp1 = 0 ;
19361 int res1 = 0 ;
19362 PyObject *swig_obj[1] ;
19363
19364 if (!args) SWIG_fail;
19365 swig_obj[0] = args;
19366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19367 if (!SWIG_IsOK(res1)) {
19368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19369 }
19370 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (bool)(arg1)->ControlDown();
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 {
19378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19379 }
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19387 PyObject *resultobj = 0;
19388 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19389 bool result;
19390 void *argp1 = 0 ;
19391 int res1 = 0 ;
19392 PyObject *swig_obj[1] ;
19393
19394 if (!args) SWIG_fail;
19395 swig_obj[0] = args;
19396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19397 if (!SWIG_IsOK(res1)) {
19398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19399 }
19400 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = (bool)(arg1)->MetaDown();
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 {
19408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19409 }
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19417 PyObject *resultobj = 0;
19418 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19419 bool result;
19420 void *argp1 = 0 ;
19421 int res1 = 0 ;
19422 PyObject *swig_obj[1] ;
19423
19424 if (!args) SWIG_fail;
19425 swig_obj[0] = args;
19426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19429 }
19430 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 result = (bool)(arg1)->ShiftDown();
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 {
19438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19439 }
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 PyObject *resultobj = 0;
19448 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19449 bool result;
19450 void *argp1 = 0 ;
19451 int res1 = 0 ;
19452 PyObject *swig_obj[1] ;
19453
19454 if (!args) SWIG_fail;
19455 swig_obj[0] = args;
19456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19459 }
19460 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (bool)(arg1)->AltDown();
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 {
19468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19469 }
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19479 bool result;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 PyObject *swig_obj[1] ;
19483
19484 if (!args) SWIG_fail;
19485 swig_obj[0] = args;
19486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19489 }
19490 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (bool)(arg1)->CmdDown();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19499 }
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 PyObject *obj;
19508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19509 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19510 return SWIG_Py_Void();
19511 }
19512
19513 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19514 return SWIG_Python_InitShadowInstance(args);
19515 }
19516
19517 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj = 0;
19519 int arg1 ;
19520 wxEventType arg2 ;
19521 wxGrid *arg3 = (wxGrid *) 0 ;
19522 int arg4 = (int) -1 ;
19523 int arg5 = (int) -1 ;
19524 int arg6 = (int) -1 ;
19525 bool arg7 = (bool) false ;
19526 bool arg8 = (bool) false ;
19527 bool arg9 = (bool) false ;
19528 bool arg10 = (bool) false ;
19529 wxGridSizeEvent *result = 0 ;
19530 int val1 ;
19531 int ecode1 = 0 ;
19532 int val2 ;
19533 int ecode2 = 0 ;
19534 void *argp3 = 0 ;
19535 int res3 = 0 ;
19536 int val4 ;
19537 int ecode4 = 0 ;
19538 int val5 ;
19539 int ecode5 = 0 ;
19540 int val6 ;
19541 int ecode6 = 0 ;
19542 bool val7 ;
19543 int ecode7 = 0 ;
19544 bool val8 ;
19545 int ecode8 = 0 ;
19546 bool val9 ;
19547 int ecode9 = 0 ;
19548 bool val10 ;
19549 int ecode10 = 0 ;
19550 PyObject * obj0 = 0 ;
19551 PyObject * obj1 = 0 ;
19552 PyObject * obj2 = 0 ;
19553 PyObject * obj3 = 0 ;
19554 PyObject * obj4 = 0 ;
19555 PyObject * obj5 = 0 ;
19556 PyObject * obj6 = 0 ;
19557 PyObject * obj7 = 0 ;
19558 PyObject * obj8 = 0 ;
19559 PyObject * obj9 = 0 ;
19560 char * kwnames[] = {
19561 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19562 };
19563
19564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19565 ecode1 = SWIG_AsVal_int(obj0, &val1);
19566 if (!SWIG_IsOK(ecode1)) {
19567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19568 }
19569 arg1 = static_cast< int >(val1);
19570 ecode2 = SWIG_AsVal_int(obj1, &val2);
19571 if (!SWIG_IsOK(ecode2)) {
19572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19573 }
19574 arg2 = static_cast< wxEventType >(val2);
19575 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19576 if (!SWIG_IsOK(res3)) {
19577 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19578 }
19579 arg3 = reinterpret_cast< wxGrid * >(argp3);
19580 if (obj3) {
19581 ecode4 = SWIG_AsVal_int(obj3, &val4);
19582 if (!SWIG_IsOK(ecode4)) {
19583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19584 }
19585 arg4 = static_cast< int >(val4);
19586 }
19587 if (obj4) {
19588 ecode5 = SWIG_AsVal_int(obj4, &val5);
19589 if (!SWIG_IsOK(ecode5)) {
19590 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19591 }
19592 arg5 = static_cast< int >(val5);
19593 }
19594 if (obj5) {
19595 ecode6 = SWIG_AsVal_int(obj5, &val6);
19596 if (!SWIG_IsOK(ecode6)) {
19597 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19598 }
19599 arg6 = static_cast< int >(val6);
19600 }
19601 if (obj6) {
19602 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19603 if (!SWIG_IsOK(ecode7)) {
19604 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19605 }
19606 arg7 = static_cast< bool >(val7);
19607 }
19608 if (obj7) {
19609 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19610 if (!SWIG_IsOK(ecode8)) {
19611 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19612 }
19613 arg8 = static_cast< bool >(val8);
19614 }
19615 if (obj8) {
19616 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19617 if (!SWIG_IsOK(ecode9)) {
19618 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19619 }
19620 arg9 = static_cast< bool >(val9);
19621 }
19622 if (obj9) {
19623 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19624 if (!SWIG_IsOK(ecode10)) {
19625 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19626 }
19627 arg10 = static_cast< bool >(val10);
19628 }
19629 {
19630 PyThreadState* __tstate = wxPyBeginAllowThreads();
19631 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19643 PyObject *resultobj = 0;
19644 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19645 int result;
19646 void *argp1 = 0 ;
19647 int res1 = 0 ;
19648 PyObject *swig_obj[1] ;
19649
19650 if (!args) SWIG_fail;
19651 swig_obj[0] = args;
19652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19653 if (!SWIG_IsOK(res1)) {
19654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19655 }
19656 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19657 {
19658 PyThreadState* __tstate = wxPyBeginAllowThreads();
19659 result = (int)(arg1)->GetRowOrCol();
19660 wxPyEndAllowThreads(__tstate);
19661 if (PyErr_Occurred()) SWIG_fail;
19662 }
19663 resultobj = SWIG_From_int(static_cast< int >(result));
19664 return resultobj;
19665 fail:
19666 return NULL;
19667 }
19668
19669
19670 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 PyObject *resultobj = 0;
19672 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19673 wxPoint result;
19674 void *argp1 = 0 ;
19675 int res1 = 0 ;
19676 PyObject *swig_obj[1] ;
19677
19678 if (!args) SWIG_fail;
19679 swig_obj[0] = args;
19680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19683 }
19684 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (arg1)->GetPosition();
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19701 bool result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19711 }
19712 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (bool)(arg1)->ControlDown();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 {
19720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19721 }
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19731 bool result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19741 }
19742 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (bool)(arg1)->MetaDown();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 {
19750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19751 }
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19759 PyObject *resultobj = 0;
19760 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19761 bool result;
19762 void *argp1 = 0 ;
19763 int res1 = 0 ;
19764 PyObject *swig_obj[1] ;
19765
19766 if (!args) SWIG_fail;
19767 swig_obj[0] = args;
19768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19769 if (!SWIG_IsOK(res1)) {
19770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19771 }
19772 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19773 {
19774 PyThreadState* __tstate = wxPyBeginAllowThreads();
19775 result = (bool)(arg1)->ShiftDown();
19776 wxPyEndAllowThreads(__tstate);
19777 if (PyErr_Occurred()) SWIG_fail;
19778 }
19779 {
19780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19781 }
19782 return resultobj;
19783 fail:
19784 return NULL;
19785 }
19786
19787
19788 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19789 PyObject *resultobj = 0;
19790 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19791 bool result;
19792 void *argp1 = 0 ;
19793 int res1 = 0 ;
19794 PyObject *swig_obj[1] ;
19795
19796 if (!args) SWIG_fail;
19797 swig_obj[0] = args;
19798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19799 if (!SWIG_IsOK(res1)) {
19800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19801 }
19802 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19803 {
19804 PyThreadState* __tstate = wxPyBeginAllowThreads();
19805 result = (bool)(arg1)->AltDown();
19806 wxPyEndAllowThreads(__tstate);
19807 if (PyErr_Occurred()) SWIG_fail;
19808 }
19809 {
19810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19811 }
19812 return resultobj;
19813 fail:
19814 return NULL;
19815 }
19816
19817
19818 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19819 PyObject *resultobj = 0;
19820 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19821 bool result;
19822 void *argp1 = 0 ;
19823 int res1 = 0 ;
19824 PyObject *swig_obj[1] ;
19825
19826 if (!args) SWIG_fail;
19827 swig_obj[0] = args;
19828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19829 if (!SWIG_IsOK(res1)) {
19830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19831 }
19832 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (bool)(arg1)->CmdDown();
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 {
19840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19841 }
19842 return resultobj;
19843 fail:
19844 return NULL;
19845 }
19846
19847
19848 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19849 PyObject *obj;
19850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19851 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19852 return SWIG_Py_Void();
19853 }
19854
19855 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19856 return SWIG_Python_InitShadowInstance(args);
19857 }
19858
19859 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj = 0;
19861 int arg1 ;
19862 wxEventType arg2 ;
19863 wxGrid *arg3 = (wxGrid *) 0 ;
19864 wxGridCellCoords *arg4 = 0 ;
19865 wxGridCellCoords *arg5 = 0 ;
19866 bool arg6 = (bool) true ;
19867 bool arg7 = (bool) false ;
19868 bool arg8 = (bool) false ;
19869 bool arg9 = (bool) false ;
19870 bool arg10 = (bool) false ;
19871 wxGridRangeSelectEvent *result = 0 ;
19872 int val1 ;
19873 int ecode1 = 0 ;
19874 int val2 ;
19875 int ecode2 = 0 ;
19876 void *argp3 = 0 ;
19877 int res3 = 0 ;
19878 wxGridCellCoords temp4 ;
19879 wxGridCellCoords temp5 ;
19880 bool val6 ;
19881 int ecode6 = 0 ;
19882 bool val7 ;
19883 int ecode7 = 0 ;
19884 bool val8 ;
19885 int ecode8 = 0 ;
19886 bool val9 ;
19887 int ecode9 = 0 ;
19888 bool val10 ;
19889 int ecode10 = 0 ;
19890 PyObject * obj0 = 0 ;
19891 PyObject * obj1 = 0 ;
19892 PyObject * obj2 = 0 ;
19893 PyObject * obj3 = 0 ;
19894 PyObject * obj4 = 0 ;
19895 PyObject * obj5 = 0 ;
19896 PyObject * obj6 = 0 ;
19897 PyObject * obj7 = 0 ;
19898 PyObject * obj8 = 0 ;
19899 PyObject * obj9 = 0 ;
19900 char * kwnames[] = {
19901 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19902 };
19903
19904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19905 ecode1 = SWIG_AsVal_int(obj0, &val1);
19906 if (!SWIG_IsOK(ecode1)) {
19907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19908 }
19909 arg1 = static_cast< int >(val1);
19910 ecode2 = SWIG_AsVal_int(obj1, &val2);
19911 if (!SWIG_IsOK(ecode2)) {
19912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19913 }
19914 arg2 = static_cast< wxEventType >(val2);
19915 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19916 if (!SWIG_IsOK(res3)) {
19917 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19918 }
19919 arg3 = reinterpret_cast< wxGrid * >(argp3);
19920 {
19921 arg4 = &temp4;
19922 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19923 }
19924 {
19925 arg5 = &temp5;
19926 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19927 }
19928 if (obj5) {
19929 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19930 if (!SWIG_IsOK(ecode6)) {
19931 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19932 }
19933 arg6 = static_cast< bool >(val6);
19934 }
19935 if (obj6) {
19936 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19937 if (!SWIG_IsOK(ecode7)) {
19938 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19939 }
19940 arg7 = static_cast< bool >(val7);
19941 }
19942 if (obj7) {
19943 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19944 if (!SWIG_IsOK(ecode8)) {
19945 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19946 }
19947 arg8 = static_cast< bool >(val8);
19948 }
19949 if (obj8) {
19950 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19951 if (!SWIG_IsOK(ecode9)) {
19952 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19953 }
19954 arg9 = static_cast< bool >(val9);
19955 }
19956 if (obj9) {
19957 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19958 if (!SWIG_IsOK(ecode10)) {
19959 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19960 }
19961 arg10 = static_cast< bool >(val10);
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19977 PyObject *resultobj = 0;
19978 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19979 wxGridCellCoords result;
19980 void *argp1 = 0 ;
19981 int res1 = 0 ;
19982 PyObject *swig_obj[1] ;
19983
19984 if (!args) SWIG_fail;
19985 swig_obj[0] = args;
19986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19987 if (!SWIG_IsOK(res1)) {
19988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19989 }
19990 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (arg1)->GetTopLeftCoords();
19994 wxPyEndAllowThreads(__tstate);
19995 if (PyErr_Occurred()) SWIG_fail;
19996 }
19997 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20005 PyObject *resultobj = 0;
20006 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20007 wxGridCellCoords result;
20008 void *argp1 = 0 ;
20009 int res1 = 0 ;
20010 PyObject *swig_obj[1] ;
20011
20012 if (!args) SWIG_fail;
20013 swig_obj[0] = args;
20014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20015 if (!SWIG_IsOK(res1)) {
20016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20017 }
20018 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 result = (arg1)->GetBottomRightCoords();
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20033 PyObject *resultobj = 0;
20034 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20035 int result;
20036 void *argp1 = 0 ;
20037 int res1 = 0 ;
20038 PyObject *swig_obj[1] ;
20039
20040 if (!args) SWIG_fail;
20041 swig_obj[0] = args;
20042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20043 if (!SWIG_IsOK(res1)) {
20044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20045 }
20046 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20047 {
20048 PyThreadState* __tstate = wxPyBeginAllowThreads();
20049 result = (int)(arg1)->GetTopRow();
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 resultobj = SWIG_From_int(static_cast< int >(result));
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20061 PyObject *resultobj = 0;
20062 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20063 int result;
20064 void *argp1 = 0 ;
20065 int res1 = 0 ;
20066 PyObject *swig_obj[1] ;
20067
20068 if (!args) SWIG_fail;
20069 swig_obj[0] = args;
20070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20071 if (!SWIG_IsOK(res1)) {
20072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20073 }
20074 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (int)(arg1)->GetBottomRow();
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 resultobj = SWIG_From_int(static_cast< int >(result));
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20089 PyObject *resultobj = 0;
20090 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20091 int result;
20092 void *argp1 = 0 ;
20093 int res1 = 0 ;
20094 PyObject *swig_obj[1] ;
20095
20096 if (!args) SWIG_fail;
20097 swig_obj[0] = args;
20098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20099 if (!SWIG_IsOK(res1)) {
20100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20101 }
20102 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20103 {
20104 PyThreadState* __tstate = wxPyBeginAllowThreads();
20105 result = (int)(arg1)->GetLeftCol();
20106 wxPyEndAllowThreads(__tstate);
20107 if (PyErr_Occurred()) SWIG_fail;
20108 }
20109 resultobj = SWIG_From_int(static_cast< int >(result));
20110 return resultobj;
20111 fail:
20112 return NULL;
20113 }
20114
20115
20116 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20117 PyObject *resultobj = 0;
20118 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20119 int result;
20120 void *argp1 = 0 ;
20121 int res1 = 0 ;
20122 PyObject *swig_obj[1] ;
20123
20124 if (!args) SWIG_fail;
20125 swig_obj[0] = args;
20126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20127 if (!SWIG_IsOK(res1)) {
20128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20129 }
20130 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (int)(arg1)->GetRightCol();
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 resultobj = SWIG_From_int(static_cast< int >(result));
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20145 PyObject *resultobj = 0;
20146 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20147 bool result;
20148 void *argp1 = 0 ;
20149 int res1 = 0 ;
20150 PyObject *swig_obj[1] ;
20151
20152 if (!args) SWIG_fail;
20153 swig_obj[0] = args;
20154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20155 if (!SWIG_IsOK(res1)) {
20156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20157 }
20158 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (bool)(arg1)->Selecting();
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 {
20166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20167 }
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *resultobj = 0;
20176 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20177 bool result;
20178 void *argp1 = 0 ;
20179 int res1 = 0 ;
20180 PyObject *swig_obj[1] ;
20181
20182 if (!args) SWIG_fail;
20183 swig_obj[0] = args;
20184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20187 }
20188 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (bool)(arg1)->ControlDown();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *resultobj = 0;
20206 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 PyObject *swig_obj[1] ;
20211
20212 if (!args) SWIG_fail;
20213 swig_obj[0] = args;
20214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20217 }
20218 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (bool)(arg1)->MetaDown();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 {
20226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20227 }
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *resultobj = 0;
20236 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20237 bool result;
20238 void *argp1 = 0 ;
20239 int res1 = 0 ;
20240 PyObject *swig_obj[1] ;
20241
20242 if (!args) SWIG_fail;
20243 swig_obj[0] = args;
20244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20245 if (!SWIG_IsOK(res1)) {
20246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20247 }
20248 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (bool)(arg1)->ShiftDown();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20265 PyObject *resultobj = 0;
20266 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20267 bool result;
20268 void *argp1 = 0 ;
20269 int res1 = 0 ;
20270 PyObject *swig_obj[1] ;
20271
20272 if (!args) SWIG_fail;
20273 swig_obj[0] = args;
20274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20277 }
20278 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (bool)(arg1)->AltDown();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 {
20286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20287 }
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 PyObject *resultobj = 0;
20296 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20297 bool result;
20298 void *argp1 = 0 ;
20299 int res1 = 0 ;
20300 PyObject *swig_obj[1] ;
20301
20302 if (!args) SWIG_fail;
20303 swig_obj[0] = args;
20304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20307 }
20308 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = (bool)(arg1)->CmdDown();
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20317 }
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 PyObject *obj;
20326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20327 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20328 return SWIG_Py_Void();
20329 }
20330
20331 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 return SWIG_Python_InitShadowInstance(args);
20333 }
20334
20335 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj = 0;
20337 int arg1 ;
20338 wxEventType arg2 ;
20339 wxObject *arg3 = (wxObject *) 0 ;
20340 int arg4 ;
20341 int arg5 ;
20342 wxControl *arg6 = (wxControl *) 0 ;
20343 wxGridEditorCreatedEvent *result = 0 ;
20344 int val1 ;
20345 int ecode1 = 0 ;
20346 int val2 ;
20347 int ecode2 = 0 ;
20348 void *argp3 = 0 ;
20349 int res3 = 0 ;
20350 int val4 ;
20351 int ecode4 = 0 ;
20352 int val5 ;
20353 int ecode5 = 0 ;
20354 void *argp6 = 0 ;
20355 int res6 = 0 ;
20356 PyObject * obj0 = 0 ;
20357 PyObject * obj1 = 0 ;
20358 PyObject * obj2 = 0 ;
20359 PyObject * obj3 = 0 ;
20360 PyObject * obj4 = 0 ;
20361 PyObject * obj5 = 0 ;
20362 char * kwnames[] = {
20363 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20364 };
20365
20366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20367 ecode1 = SWIG_AsVal_int(obj0, &val1);
20368 if (!SWIG_IsOK(ecode1)) {
20369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20370 }
20371 arg1 = static_cast< int >(val1);
20372 ecode2 = SWIG_AsVal_int(obj1, &val2);
20373 if (!SWIG_IsOK(ecode2)) {
20374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20375 }
20376 arg2 = static_cast< wxEventType >(val2);
20377 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20378 if (!SWIG_IsOK(res3)) {
20379 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20380 }
20381 arg3 = reinterpret_cast< wxObject * >(argp3);
20382 ecode4 = SWIG_AsVal_int(obj3, &val4);
20383 if (!SWIG_IsOK(ecode4)) {
20384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20385 }
20386 arg4 = static_cast< int >(val4);
20387 ecode5 = SWIG_AsVal_int(obj4, &val5);
20388 if (!SWIG_IsOK(ecode5)) {
20389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20390 }
20391 arg5 = static_cast< int >(val5);
20392 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20393 if (!SWIG_IsOK(res6)) {
20394 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20395 }
20396 arg6 = reinterpret_cast< wxControl * >(argp6);
20397 {
20398 PyThreadState* __tstate = wxPyBeginAllowThreads();
20399 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20400 wxPyEndAllowThreads(__tstate);
20401 if (PyErr_Occurred()) SWIG_fail;
20402 }
20403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20404 return resultobj;
20405 fail:
20406 return NULL;
20407 }
20408
20409
20410 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 PyObject *resultobj = 0;
20412 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20413 int result;
20414 void *argp1 = 0 ;
20415 int res1 = 0 ;
20416 PyObject *swig_obj[1] ;
20417
20418 if (!args) SWIG_fail;
20419 swig_obj[0] = args;
20420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20421 if (!SWIG_IsOK(res1)) {
20422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20423 }
20424 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = (int)(arg1)->GetRow();
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 resultobj = SWIG_From_int(static_cast< int >(result));
20432 return resultobj;
20433 fail:
20434 return NULL;
20435 }
20436
20437
20438 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20439 PyObject *resultobj = 0;
20440 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20441 int result;
20442 void *argp1 = 0 ;
20443 int res1 = 0 ;
20444 PyObject *swig_obj[1] ;
20445
20446 if (!args) SWIG_fail;
20447 swig_obj[0] = args;
20448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20449 if (!SWIG_IsOK(res1)) {
20450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20451 }
20452 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (int)(arg1)->GetCol();
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_From_int(static_cast< int >(result));
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *resultobj = 0;
20468 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20469 wxControl *result = 0 ;
20470 void *argp1 = 0 ;
20471 int res1 = 0 ;
20472 PyObject *swig_obj[1] ;
20473
20474 if (!args) SWIG_fail;
20475 swig_obj[0] = args;
20476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20477 if (!SWIG_IsOK(res1)) {
20478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20479 }
20480 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (wxControl *)(arg1)->GetControl();
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 {
20488 resultobj = wxPyMake_wxObject(result, 0);
20489 }
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj = 0;
20498 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20499 int arg2 ;
20500 void *argp1 = 0 ;
20501 int res1 = 0 ;
20502 int val2 ;
20503 int ecode2 = 0 ;
20504 PyObject * obj0 = 0 ;
20505 PyObject * obj1 = 0 ;
20506 char * kwnames[] = {
20507 (char *) "self",(char *) "row", NULL
20508 };
20509
20510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20512 if (!SWIG_IsOK(res1)) {
20513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20514 }
20515 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20516 ecode2 = SWIG_AsVal_int(obj1, &val2);
20517 if (!SWIG_IsOK(ecode2)) {
20518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20519 }
20520 arg2 = static_cast< int >(val2);
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 (arg1)->SetRow(arg2);
20524 wxPyEndAllowThreads(__tstate);
20525 if (PyErr_Occurred()) SWIG_fail;
20526 }
20527 resultobj = SWIG_Py_Void();
20528 return resultobj;
20529 fail:
20530 return NULL;
20531 }
20532
20533
20534 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20535 PyObject *resultobj = 0;
20536 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20537 int arg2 ;
20538 void *argp1 = 0 ;
20539 int res1 = 0 ;
20540 int val2 ;
20541 int ecode2 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 char * kwnames[] = {
20545 (char *) "self",(char *) "col", NULL
20546 };
20547
20548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20552 }
20553 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20554 ecode2 = SWIG_AsVal_int(obj1, &val2);
20555 if (!SWIG_IsOK(ecode2)) {
20556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20557 }
20558 arg2 = static_cast< int >(val2);
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 (arg1)->SetCol(arg2);
20562 wxPyEndAllowThreads(__tstate);
20563 if (PyErr_Occurred()) SWIG_fail;
20564 }
20565 resultobj = SWIG_Py_Void();
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20573 PyObject *resultobj = 0;
20574 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20575 wxControl *arg2 = (wxControl *) 0 ;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 void *argp2 = 0 ;
20579 int res2 = 0 ;
20580 PyObject * obj0 = 0 ;
20581 PyObject * obj1 = 0 ;
20582 char * kwnames[] = {
20583 (char *) "self",(char *) "ctrl", NULL
20584 };
20585
20586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20588 if (!SWIG_IsOK(res1)) {
20589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20590 }
20591 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20592 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20593 if (!SWIG_IsOK(res2)) {
20594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20595 }
20596 arg2 = reinterpret_cast< wxControl * >(argp2);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 (arg1)->SetControl(arg2);
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 resultobj = SWIG_Py_Void();
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *obj;
20612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20613 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20614 return SWIG_Py_Void();
20615 }
20616
20617 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 return SWIG_Python_InitShadowInstance(args);
20619 }
20620
20621 static PyMethodDef SwigMethods[] = {
20622 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20624 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20626 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20627 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20628 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20631 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20632 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20633 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20636 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20637 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20638 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20639 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20640 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20641 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20642 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20643 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20645 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20647 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20649 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20650 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20651 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20652 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20653 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20655 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20656 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20658 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20659 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20660 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20661 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20662 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20663 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20664 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20666 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20671 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20672 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20678 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20680 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20681 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20682 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20685 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20686 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20687 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20688 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20689 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20690 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20692 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20693 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20695 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20696 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20697 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20700 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20701 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20703 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20704 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20706 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20707 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20708 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20709 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20710 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20713 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20714 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20716 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20717 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20728 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20729 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20730 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20731 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20732 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20733 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20734 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20735 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20736 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20737 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20738 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20739 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20740 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20741 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20744 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20745 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20747 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20748 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20749 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20757 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20758 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20759 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20765 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20766 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20767 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20770 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20772 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20773 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20774 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20787 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20798 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20803 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20804 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20806 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20807 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20808 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20810 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20811 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20813 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20815 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20817 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20819 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20821 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20822 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20823 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20825 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20826 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20828 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20833 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20834 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20835 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20837 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20841 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20842 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20843 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20845 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20847 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20857 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20858 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20859 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20860 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20861 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20864 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20865 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20866 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20867 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20868 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20869 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20870 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20871 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20878 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20879 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20887 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20888 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20893 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20894 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20895 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20896 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20897 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20898 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20899 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20900 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20901 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20902 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20905 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20906 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20909 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20910 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20911 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20927 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20928 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20930 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20931 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20933 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20934 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20936 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20937 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20939 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20940 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20950 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20951 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20953 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20955 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20957 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20959 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20961 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20963 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20977 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20984 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20985 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20999 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21003 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21012 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21013 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21014 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21016 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21017 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21018 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21019 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21020 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21025 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21026 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21035 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21036 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21037 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21038 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21041 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21042 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21046 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21047 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21049 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21050 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21051 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21052 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21053 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21054 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21055 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21056 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21057 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21058 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21059 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21061 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21062 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21063 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21064 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21065 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21066 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21067 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21068 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21069 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21071 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21072 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21073 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21074 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21075 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21076 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21077 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21078 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21079 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21080 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21081 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21082 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21083 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21084 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21086 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21087 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21088 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21092 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21093 { NULL, NULL, 0, NULL }
21094 };
21095
21096
21097 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21098
21099 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21100 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21101 }
21102 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21103 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21104 }
21105 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21106 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21107 }
21108 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21109 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21110 }
21111 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21112 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21113 }
21114 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21115 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21116 }
21117 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21118 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21119 }
21120 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21121 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21122 }
21123 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21124 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21125 }
21126 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21127 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21128 }
21129 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21130 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21131 }
21132 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21133 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21134 }
21135 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21136 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21137 }
21138 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21139 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21140 }
21141 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21142 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21143 }
21144 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21145 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21146 }
21147 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21148 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21149 }
21150 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21151 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21152 }
21153 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21154 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21155 }
21156 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21157 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21158 }
21159 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21160 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21161 }
21162 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21163 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21164 }
21165 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21166 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21167 }
21168 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21169 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21170 }
21171 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21172 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21173 }
21174 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21175 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21176 }
21177 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21178 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21179 }
21180 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21181 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21182 }
21183 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21184 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21185 }
21186 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21187 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21188 }
21189 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21190 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21191 }
21192 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21193 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21194 }
21195 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21196 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21197 }
21198 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21199 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21200 }
21201 static void *_p_wxGridTo_p_wxPanel(void *x) {
21202 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21203 }
21204 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21205 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21206 }
21207 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21208 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21209 }
21210 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21211 return (void *)((wxPanel *) ((wxPyPanel *) x));
21212 }
21213 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21214 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21215 }
21216 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21217 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21218 }
21219 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21220 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21221 }
21222 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21223 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21224 }
21225 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21226 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21227 }
21228 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21229 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21230 }
21231 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21232 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21233 }
21234 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21235 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21236 }
21237 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21238 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21239 }
21240 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21241 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21242 }
21243 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21244 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21245 }
21246 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21247 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21248 }
21249 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21250 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21251 }
21252 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21253 return (void *)((wxWindow *) ((wxMenuBar *) x));
21254 }
21255 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21256 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21257 }
21258 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21259 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21260 }
21261 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21262 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21263 }
21264 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21265 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21266 }
21267 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21268 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21269 }
21270 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21271 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21272 }
21273 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21274 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21275 }
21276 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21277 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21278 }
21279 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21280 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21281 }
21282 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21283 return (void *)((wxWindow *) ((wxPanel *) x));
21284 }
21285 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21286 return (void *)((wxWindow *) ((wxStatusBar *) x));
21287 }
21288 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21289 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21290 }
21291 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21292 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21293 }
21294 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21295 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21296 }
21297 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21298 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21299 }
21300 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21301 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21302 }
21303 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21304 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21305 }
21306 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21307 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21308 }
21309 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21310 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21311 }
21312 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21313 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21314 }
21315 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21316 return (void *)((wxWindow *) ((wxSashWindow *) x));
21317 }
21318 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21319 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21320 }
21321 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21322 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21323 }
21324 static void *_p_wxControlTo_p_wxWindow(void *x) {
21325 return (void *)((wxWindow *) ((wxControl *) x));
21326 }
21327 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21328 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21329 }
21330 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21331 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21332 }
21333 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21334 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21335 }
21336 static void *_p_wxGridTo_p_wxWindow(void *x) {
21337 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21338 }
21339 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21340 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21341 }
21342 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21343 return (void *)((wxWindow *) ((wxPyWindow *) x));
21344 }
21345 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21346 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21347 }
21348 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21349 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21350 }
21351 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21352 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21353 }
21354 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21355 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21356 }
21357 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21358 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21359 }
21360 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21361 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21362 }
21363 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21364 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21365 }
21366 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21367 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21368 }
21369 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21370 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21371 }
21372 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21373 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21374 }
21375 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21376 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21377 }
21378 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21379 return (void *)((wxControl *) ((wxControlWithItems *) x));
21380 }
21381 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21382 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21383 }
21384 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21385 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21386 }
21387 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21388 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21389 }
21390 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21391 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21392 }
21393 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21394 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21395 }
21396 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21397 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21398 }
21399 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21400 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21401 }
21402 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21403 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21404 }
21405 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21406 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21407 }
21408 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21409 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21410 }
21411 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21412 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21413 }
21414 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21415 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21416 }
21417 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21418 return (void *)((wxEvent *) ((wxPyEvent *) x));
21419 }
21420 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21421 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21422 }
21423 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21424 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21425 }
21426 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21427 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21428 }
21429 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21430 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21431 }
21432 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21433 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21434 }
21435 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21436 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21437 }
21438 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21439 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21440 }
21441 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21442 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21443 }
21444 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21445 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21446 }
21447 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21448 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21449 }
21450 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21451 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21452 }
21453 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21454 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21455 }
21456 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21457 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21458 }
21459 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21460 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21461 }
21462 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21463 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21464 }
21465 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21466 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21467 }
21468 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21469 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21470 }
21471 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21472 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21473 }
21474 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21475 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21476 }
21477 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21478 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21479 }
21480 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21481 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21482 }
21483 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21484 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21485 }
21486 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21487 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21488 }
21489 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21490 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21491 }
21492 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21493 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21494 }
21495 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21496 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21497 }
21498 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21499 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21500 }
21501 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21502 return (void *)((wxEvent *) ((wxShowEvent *) x));
21503 }
21504 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21505 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21506 }
21507 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21508 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21509 }
21510 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21511 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21512 }
21513 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21514 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21515 }
21516 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21517 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21518 }
21519 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21520 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21521 }
21522 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21523 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21524 }
21525 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21526 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21527 }
21528 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21529 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21530 }
21531 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21532 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21533 }
21534 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21535 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21536 }
21537 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21538 return (void *)((wxObject *) ((wxSizerItem *) x));
21539 }
21540 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21541 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21542 }
21543 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21544 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21545 }
21546 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21547 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21548 }
21549 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21550 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21551 }
21552 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21553 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21554 }
21555 static void *_p_wxSizerTo_p_wxObject(void *x) {
21556 return (void *)((wxObject *) ((wxSizer *) x));
21557 }
21558 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21559 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21560 }
21561 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21562 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21563 }
21564 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21565 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21566 }
21567 static void *_p_wxEventTo_p_wxObject(void *x) {
21568 return (void *)((wxObject *) ((wxEvent *) x));
21569 }
21570 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21571 return (void *)((wxObject *) ((wxFontData *) x));
21572 }
21573 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21574 return (void *)((wxObject *) ((wxPrintData *) x));
21575 }
21576 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21577 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21578 }
21579 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21580 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21581 }
21582 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21583 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21584 }
21585 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21586 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21587 }
21588 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21589 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21590 }
21591 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21592 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21593 }
21594 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21595 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21596 }
21597 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21598 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21599 }
21600 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21601 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21602 }
21603 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21604 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21605 }
21606 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21607 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21608 }
21609 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21610 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21611 }
21612 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21613 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21614 }
21615 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21616 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21617 }
21618 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21619 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21620 }
21621 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21623 }
21624 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21625 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21626 }
21627 static void *_p_wxControlTo_p_wxObject(void *x) {
21628 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21629 }
21630 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21631 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21632 }
21633 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21635 }
21636 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21637 return (void *)((wxObject *) ((wxFSFile *) x));
21638 }
21639 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21640 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21641 }
21642 static void *_p_wxGridTo_p_wxObject(void *x) {
21643 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21644 }
21645 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21646 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21647 }
21648 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21649 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21650 }
21651 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21652 return (void *)((wxObject *) ((wxColourData *) x));
21653 }
21654 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21655 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21656 }
21657 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21659 }
21660 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21661 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21662 }
21663 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21664 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21665 }
21666 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21667 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21668 }
21669 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21670 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21671 }
21672 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21673 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21674 }
21675 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21677 }
21678 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21679 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21680 }
21681 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21682 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21683 }
21684 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21685 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21686 }
21687 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21688 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21689 }
21690 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21691 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21692 }
21693 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21694 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21695 }
21696 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21697 return (void *)((wxObject *) ((wxPrinter *) x));
21698 }
21699 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21700 return (void *)((wxObject *) ((wxMenuItem *) x));
21701 }
21702 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21703 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21704 }
21705 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21706 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21707 }
21708 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21709 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21710 }
21711 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21712 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21713 }
21714 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21715 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21716 }
21717 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21718 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21719 }
21720 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21721 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21722 }
21723 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21724 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21725 }
21726 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21727 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21728 }
21729 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21730 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21731 }
21732 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21733 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21734 }
21735 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21736 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21737 }
21738 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21739 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21740 }
21741 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21742 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21743 }
21744 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21745 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21746 }
21747 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21748 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21749 }
21750 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21751 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21752 }
21753 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21754 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21755 }
21756 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21757 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21758 }
21759 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21760 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21761 }
21762 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21763 return (void *)((wxObject *) ((wxImageHandler *) x));
21764 }
21765 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21766 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21767 }
21768 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21769 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21770 }
21771 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21772 return (void *)((wxObject *) ((wxEvtHandler *) x));
21773 }
21774 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21775 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21776 }
21777 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21778 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21779 }
21780 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21781 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21782 }
21783 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21784 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21785 }
21786 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21787 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21788 }
21789 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21790 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21791 }
21792 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21793 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21794 }
21795 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21796 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21797 }
21798 static void *_p_wxImageTo_p_wxObject(void *x) {
21799 return (void *)((wxObject *) ((wxImage *) x));
21800 }
21801 static void *_p_wxFrameTo_p_wxObject(void *x) {
21802 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21803 }
21804 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21805 return (void *)((wxObject *) ((wxPyPrintout *) x));
21806 }
21807 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21808 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21809 }
21810 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21811 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21812 }
21813 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21814 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21815 }
21816 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21817 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21818 }
21819 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21820 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21821 }
21822 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21823 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21824 }
21825 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21826 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21827 }
21828 static void *_p_wxWindowTo_p_wxObject(void *x) {
21829 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21830 }
21831 static void *_p_wxMenuTo_p_wxObject(void *x) {
21832 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21833 }
21834 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21835 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21836 }
21837 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21838 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21839 }
21840 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21841 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21842 }
21843 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21844 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21845 }
21846 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21847 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21848 }
21849 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21850 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21851 }
21852 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21853 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21854 }
21855 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21856 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21857 }
21858 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21859 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21860 }
21861 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21862 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21863 }
21864 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21865 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21866 }
21867 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21868 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21869 }
21870 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21871 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21872 }
21873 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21874 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21875 }
21876 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21877 return (void *)((wxObject *) ((wxPrintPreview *) x));
21878 }
21879 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21880 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21881 }
21882 static void *_p_wxPanelTo_p_wxObject(void *x) {
21883 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21884 }
21885 static void *_p_wxDialogTo_p_wxObject(void *x) {
21886 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21887 }
21888 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21889 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21890 }
21891 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21892 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21893 }
21894 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21895 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21896 }
21897 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21898 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21899 }
21900 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21901 return (void *)((wxObject *) ((wxPrintDialog *) x));
21902 }
21903 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21904 return (void *)((wxObject *) ((wxFileSystem *) x));
21905 }
21906 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21907 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21908 }
21909 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21910 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21911 }
21912 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21913 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21914 }
21915 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21916 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21917 }
21918 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21919 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21920 }
21921 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21922 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21923 }
21924 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21925 return (void *)((wxObject *) ((wxGridTableBase *) x));
21926 }
21927 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21928 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21929 }
21930 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21931 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21932 }
21933 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21934 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21935 }
21936 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21937 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21938 }
21939 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21940 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21941 }
21942 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21943 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21944 }
21945 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21946 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21947 }
21948 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21949 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21950 }
21951 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21952 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21953 }
21954 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21955 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21956 }
21957 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21958 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21959 }
21960 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21961 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21962 }
21963 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21964 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21965 }
21966 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21967 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21968 }
21969 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21970 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21971 }
21972 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21973 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21974 }
21975 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21976 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21977 }
21978 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21979 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21980 }
21981 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21982 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21983 }
21984 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21985 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21986 }
21987 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21988 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21989 }
21990 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21991 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21992 }
21993 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21994 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21995 }
21996 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21997 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21998 }
21999 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22000 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22001 }
22002 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22003 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22004 }
22005 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22006 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22007 }
22008 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22009 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22010 }
22011 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22012 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22013 }
22014 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22015 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22016 }
22017 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22018 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22019 }
22020 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22021 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22022 }
22023 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22024 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22025 }
22026 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22027 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22028 }
22029 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22030 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22031 }
22032 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22033 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22034 }
22035 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22036 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22037 }
22038 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22039 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22040 }
22041 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22042 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22043 }
22044 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22045 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22046 }
22047 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22048 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22049 }
22050 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22051 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22052 }
22053 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22054 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22055 }
22056 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22057 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22058 }
22059 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22060 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22061 }
22062 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22063 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22064 }
22065 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22066 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22067 }
22068 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22069 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22070 }
22071 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22072 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22073 }
22074 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22075 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22076 }
22077 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22078 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22079 }
22080 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22081 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22082 }
22083 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22084 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22085 }
22086 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22087 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22088 }
22089 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22090 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22091 }
22092 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22093 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22094 }
22095 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22096 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22097 }
22098 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22099 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22100 }
22101 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22102 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22103 }
22104 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22105 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22106 }
22107 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22108 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22109 }
22110 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22111 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22112 }
22113 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22114 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22115 }
22116 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22117 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22118 }
22119 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22120 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22121 }
22122 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22123 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22124 }
22125 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22126 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22127 }
22128 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22129 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22130 }
22131 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22132 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22133 }
22134 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22135 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22136 }
22137 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22138 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22139 }
22140 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22141 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22142 }
22143 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22144 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22145 }
22146 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22147 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22148 }
22149 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22150 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22151 }
22152 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22153 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22154 }
22155 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22156 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22157 }
22158 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22159 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22160 }
22161 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22162 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22163 }
22164 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22165 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22166 }
22167 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22168 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22169 }
22170 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22171 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22172 }
22173 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22174 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22175 }
22176 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22177 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22178 }
22179 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22180 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22181 }
22182 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22183 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22184 }
22185 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22186 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22187 }
22188 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22189 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22190 }
22191 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22192 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22193 }
22194 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22195 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22196 }
22197 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22198 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22199 }
22200 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22201 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22202 }
22203 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22204 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22205 }
22206 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22207 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22208 }
22209 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22210 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22211 }
22212 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22213 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22214 }
22215 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22216 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};
22217 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22218 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22219 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22220 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22221 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22222 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22223 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22224 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22225 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22226 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22227 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22228 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22229 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22230 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22231 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22232 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22233 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22234 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22235 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22236 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22237 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22238 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22239 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22240 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22241 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22242 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22243 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22244 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22245 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22246 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22247 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22248 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22249 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22250 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22255 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22256 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22257 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22258 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22259 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22260 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22263 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22265 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22266 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22267 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22272 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22273 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22274 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22275 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22276 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22277 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22278 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22279 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22280 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22281 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22282 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22283 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22284 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22285 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22286 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22287 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22288 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22289 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22290 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22291 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22292 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22293 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22294 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22295 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22296 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22297 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22298 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22299 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22300 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22301 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22302 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22303 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22304 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22305 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22306 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22307 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22308 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22309 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22310 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22311 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22312 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22313 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22314 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22315 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22316 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22317 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22318 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22319 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22320 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22321 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22322 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22323 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22324 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22325 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22326 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22327 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22328 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22329 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22330 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22331 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22332 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22333 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22334 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22335 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22336 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22337 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22338 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22339 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22340 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22341 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22342 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22343 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22344 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22345 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22346 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22347 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22348 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22349 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22350 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22351 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22352 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22353 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22354 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22355 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22356 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22357 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22358 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22359 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22360 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22361 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22362 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22363 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22364 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22365 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22366 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22367 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22368 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22369 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22370 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22371 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22372 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22373 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22374 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22375 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22376 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22378 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22380 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22381 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22382 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22393 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22394 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22395 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22396 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22397 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22398 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22399 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22400 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22401 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22402 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22403 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22404 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22405 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22406
22407 static swig_type_info *swig_type_initial[] = {
22408 &_swigt__p_char,
22409 &_swigt__p_form_ops_t,
22410 &_swigt__p_int,
22411 &_swigt__p_long,
22412 &_swigt__p_unsigned_char,
22413 &_swigt__p_unsigned_int,
22414 &_swigt__p_unsigned_long,
22415 &_swigt__p_wxANIHandler,
22416 &_swigt__p_wxAcceleratorTable,
22417 &_swigt__p_wxActivateEvent,
22418 &_swigt__p_wxArrayString,
22419 &_swigt__p_wxBMPHandler,
22420 &_swigt__p_wxBoxSizer,
22421 &_swigt__p_wxCURHandler,
22422 &_swigt__p_wxCalculateLayoutEvent,
22423 &_swigt__p_wxChildFocusEvent,
22424 &_swigt__p_wxClipboardTextEvent,
22425 &_swigt__p_wxCloseEvent,
22426 &_swigt__p_wxColour,
22427 &_swigt__p_wxColourData,
22428 &_swigt__p_wxColourDialog,
22429 &_swigt__p_wxCommandEvent,
22430 &_swigt__p_wxContextMenuEvent,
22431 &_swigt__p_wxControl,
22432 &_swigt__p_wxControlWithItems,
22433 &_swigt__p_wxDC,
22434 &_swigt__p_wxDateEvent,
22435 &_swigt__p_wxDialog,
22436 &_swigt__p_wxDirDialog,
22437 &_swigt__p_wxDisplayChangedEvent,
22438 &_swigt__p_wxDropFilesEvent,
22439 &_swigt__p_wxDuplexMode,
22440 &_swigt__p_wxEraseEvent,
22441 &_swigt__p_wxEvent,
22442 &_swigt__p_wxEvtHandler,
22443 &_swigt__p_wxFSFile,
22444 &_swigt__p_wxFileDialog,
22445 &_swigt__p_wxFileSystem,
22446 &_swigt__p_wxFindDialogEvent,
22447 &_swigt__p_wxFindReplaceData,
22448 &_swigt__p_wxFindReplaceDialog,
22449 &_swigt__p_wxFlexGridSizer,
22450 &_swigt__p_wxFocusEvent,
22451 &_swigt__p_wxFont,
22452 &_swigt__p_wxFontData,
22453 &_swigt__p_wxFontDialog,
22454 &_swigt__p_wxFrame,
22455 &_swigt__p_wxGBSizerItem,
22456 &_swigt__p_wxGIFHandler,
22457 &_swigt__p_wxGrid,
22458 &_swigt__p_wxGridBagSizer,
22459 &_swigt__p_wxGridCellAttr,
22460 &_swigt__p_wxGridCellAttrProvider,
22461 &_swigt__p_wxGridCellAutoWrapStringEditor,
22462 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22463 &_swigt__p_wxGridCellBoolEditor,
22464 &_swigt__p_wxGridCellBoolRenderer,
22465 &_swigt__p_wxGridCellChoiceEditor,
22466 &_swigt__p_wxGridCellCoords,
22467 &_swigt__p_wxGridCellDateTimeRenderer,
22468 &_swigt__p_wxGridCellEditor,
22469 &_swigt__p_wxGridCellEnumEditor,
22470 &_swigt__p_wxGridCellEnumRenderer,
22471 &_swigt__p_wxGridCellFloatEditor,
22472 &_swigt__p_wxGridCellFloatRenderer,
22473 &_swigt__p_wxGridCellNumberEditor,
22474 &_swigt__p_wxGridCellNumberRenderer,
22475 &_swigt__p_wxGridCellRenderer,
22476 &_swigt__p_wxGridCellStringRenderer,
22477 &_swigt__p_wxGridCellTextEditor,
22478 &_swigt__p_wxGridCellWorker,
22479 &_swigt__p_wxGridEditorCreatedEvent,
22480 &_swigt__p_wxGridEvent,
22481 &_swigt__p_wxGridRangeSelectEvent,
22482 &_swigt__p_wxGridSizeEvent,
22483 &_swigt__p_wxGridSizer,
22484 &_swigt__p_wxGridStringTable,
22485 &_swigt__p_wxGridTableBase,
22486 &_swigt__p_wxGridTableMessage,
22487 &_swigt__p_wxICOHandler,
22488 &_swigt__p_wxIconizeEvent,
22489 &_swigt__p_wxIdleEvent,
22490 &_swigt__p_wxImage,
22491 &_swigt__p_wxImageHandler,
22492 &_swigt__p_wxIndividualLayoutConstraint,
22493 &_swigt__p_wxInitDialogEvent,
22494 &_swigt__p_wxJPEGHandler,
22495 &_swigt__p_wxKeyEvent,
22496 &_swigt__p_wxLayoutAlgorithm,
22497 &_swigt__p_wxLayoutConstraints,
22498 &_swigt__p_wxMDIChildFrame,
22499 &_swigt__p_wxMDIClientWindow,
22500 &_swigt__p_wxMDIParentFrame,
22501 &_swigt__p_wxMaximizeEvent,
22502 &_swigt__p_wxMenu,
22503 &_swigt__p_wxMenuBar,
22504 &_swigt__p_wxMenuEvent,
22505 &_swigt__p_wxMenuItem,
22506 &_swigt__p_wxMessageDialog,
22507 &_swigt__p_wxMiniFrame,
22508 &_swigt__p_wxMouseCaptureChangedEvent,
22509 &_swigt__p_wxMouseCaptureLostEvent,
22510 &_swigt__p_wxMouseEvent,
22511 &_swigt__p_wxMoveEvent,
22512 &_swigt__p_wxMultiChoiceDialog,
22513 &_swigt__p_wxNavigationKeyEvent,
22514 &_swigt__p_wxNcPaintEvent,
22515 &_swigt__p_wxNotifyEvent,
22516 &_swigt__p_wxNumberEntryDialog,
22517 &_swigt__p_wxObject,
22518 &_swigt__p_wxPCXHandler,
22519 &_swigt__p_wxPNGHandler,
22520 &_swigt__p_wxPNMHandler,
22521 &_swigt__p_wxPageSetupDialog,
22522 &_swigt__p_wxPageSetupDialogData,
22523 &_swigt__p_wxPaintEvent,
22524 &_swigt__p_wxPaletteChangedEvent,
22525 &_swigt__p_wxPanel,
22526 &_swigt__p_wxPaperSize,
22527 &_swigt__p_wxPasswordEntryDialog,
22528 &_swigt__p_wxPen,
22529 &_swigt__p_wxPoint,
22530 &_swigt__p_wxPopupWindow,
22531 &_swigt__p_wxPreviewCanvas,
22532 &_swigt__p_wxPreviewControlBar,
22533 &_swigt__p_wxPreviewFrame,
22534 &_swigt__p_wxPrintData,
22535 &_swigt__p_wxPrintDialog,
22536 &_swigt__p_wxPrintDialogData,
22537 &_swigt__p_wxPrintPreview,
22538 &_swigt__p_wxPrinter,
22539 &_swigt__p_wxProgressDialog,
22540 &_swigt__p_wxPyApp,
22541 &_swigt__p_wxPyCommandEvent,
22542 &_swigt__p_wxPyEvent,
22543 &_swigt__p_wxPyGridCellAttrProvider,
22544 &_swigt__p_wxPyGridCellEditor,
22545 &_swigt__p_wxPyGridCellRenderer,
22546 &_swigt__p_wxPyGridTableBase,
22547 &_swigt__p_wxPyHtmlListBox,
22548 &_swigt__p_wxPyImageHandler,
22549 &_swigt__p_wxPyPanel,
22550 &_swigt__p_wxPyPopupTransientWindow,
22551 &_swigt__p_wxPyPreviewControlBar,
22552 &_swigt__p_wxPyPreviewFrame,
22553 &_swigt__p_wxPyPrintPreview,
22554 &_swigt__p_wxPyPrintout,
22555 &_swigt__p_wxPyScrolledWindow,
22556 &_swigt__p_wxPySizer,
22557 &_swigt__p_wxPyTaskBarIcon,
22558 &_swigt__p_wxPyVListBox,
22559 &_swigt__p_wxPyVScrolledWindow,
22560 &_swigt__p_wxPyValidator,
22561 &_swigt__p_wxPyWindow,
22562 &_swigt__p_wxQueryLayoutInfoEvent,
22563 &_swigt__p_wxQueryNewPaletteEvent,
22564 &_swigt__p_wxRect,
22565 &_swigt__p_wxSashEvent,
22566 &_swigt__p_wxSashLayoutWindow,
22567 &_swigt__p_wxSashWindow,
22568 &_swigt__p_wxScrollEvent,
22569 &_swigt__p_wxScrollWinEvent,
22570 &_swigt__p_wxScrolledWindow,
22571 &_swigt__p_wxSetCursorEvent,
22572 &_swigt__p_wxShowEvent,
22573 &_swigt__p_wxSingleChoiceDialog,
22574 &_swigt__p_wxSize,
22575 &_swigt__p_wxSizeEvent,
22576 &_swigt__p_wxSizer,
22577 &_swigt__p_wxSizerItem,
22578 &_swigt__p_wxSplashScreen,
22579 &_swigt__p_wxSplashScreenWindow,
22580 &_swigt__p_wxSplitterEvent,
22581 &_swigt__p_wxSplitterWindow,
22582 &_swigt__p_wxStaticBoxSizer,
22583 &_swigt__p_wxStatusBar,
22584 &_swigt__p_wxStdDialogButtonSizer,
22585 &_swigt__p_wxString,
22586 &_swigt__p_wxSysColourChangedEvent,
22587 &_swigt__p_wxTIFFHandler,
22588 &_swigt__p_wxTaskBarIconEvent,
22589 &_swigt__p_wxTextEntryDialog,
22590 &_swigt__p_wxTipWindow,
22591 &_swigt__p_wxTopLevelWindow,
22592 &_swigt__p_wxUpdateUIEvent,
22593 &_swigt__p_wxValidator,
22594 &_swigt__p_wxVisualAttributes,
22595 &_swigt__p_wxWindow,
22596 &_swigt__p_wxWindowCreateEvent,
22597 &_swigt__p_wxWindowDestroyEvent,
22598 &_swigt__p_wxXPMHandler,
22599 };
22600
22601 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22602 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22603 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22604 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22605 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22606 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22607 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22608 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22609 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22610 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22611 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22612 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22613 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22614 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22615 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22616 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22617 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22618 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22619 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22620 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22621 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22622 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
22623 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22624 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}};
22625 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22626 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22627 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22628 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22629 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22630 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22631 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22632 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22643 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22644 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22645 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22646 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22647 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22653 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22654 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22655 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22656 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22658 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22659 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22662 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22663 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22667 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22668 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22672 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22673 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22674 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22675 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22676 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22677 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22678 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22679 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22680 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22681 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22682 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22683 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22684 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22685 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22686 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22687 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22688 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22689 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22690 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22691 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22692 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22693 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22694 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22695 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22696 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22697 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22698 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22699 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22700 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22701 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22702 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22703 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22704 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22705 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22706 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}};
22707 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22708 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22709 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22710 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22711 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}};
22712 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22713 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22714 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}};
22715 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22716 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22717 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22718 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22719 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22720 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22721 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}};
22722 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}};
22723 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}};
22724 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}};
22725 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22726 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22727 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22728 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22729 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22730 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}};
22731 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22732 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22733 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}};
22734 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22735 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22736 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22737 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22738 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22739 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22740 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22741 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22742 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22743 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22744 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22745 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22746 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22747 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22748 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22749 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22752 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22753 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22754 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22755 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22756 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22757 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22758 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22763 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22764 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22766 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22767 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22770 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22771 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22772 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22773 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22778 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}};
22779 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22787 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}};
22788 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22792
22793 static swig_cast_info *swig_cast_initial[] = {
22794 _swigc__p_char,
22795 _swigc__p_form_ops_t,
22796 _swigc__p_int,
22797 _swigc__p_long,
22798 _swigc__p_unsigned_char,
22799 _swigc__p_unsigned_int,
22800 _swigc__p_unsigned_long,
22801 _swigc__p_wxANIHandler,
22802 _swigc__p_wxAcceleratorTable,
22803 _swigc__p_wxActivateEvent,
22804 _swigc__p_wxArrayString,
22805 _swigc__p_wxBMPHandler,
22806 _swigc__p_wxBoxSizer,
22807 _swigc__p_wxCURHandler,
22808 _swigc__p_wxCalculateLayoutEvent,
22809 _swigc__p_wxChildFocusEvent,
22810 _swigc__p_wxClipboardTextEvent,
22811 _swigc__p_wxCloseEvent,
22812 _swigc__p_wxColour,
22813 _swigc__p_wxColourData,
22814 _swigc__p_wxColourDialog,
22815 _swigc__p_wxCommandEvent,
22816 _swigc__p_wxContextMenuEvent,
22817 _swigc__p_wxControl,
22818 _swigc__p_wxControlWithItems,
22819 _swigc__p_wxDC,
22820 _swigc__p_wxDateEvent,
22821 _swigc__p_wxDialog,
22822 _swigc__p_wxDirDialog,
22823 _swigc__p_wxDisplayChangedEvent,
22824 _swigc__p_wxDropFilesEvent,
22825 _swigc__p_wxDuplexMode,
22826 _swigc__p_wxEraseEvent,
22827 _swigc__p_wxEvent,
22828 _swigc__p_wxEvtHandler,
22829 _swigc__p_wxFSFile,
22830 _swigc__p_wxFileDialog,
22831 _swigc__p_wxFileSystem,
22832 _swigc__p_wxFindDialogEvent,
22833 _swigc__p_wxFindReplaceData,
22834 _swigc__p_wxFindReplaceDialog,
22835 _swigc__p_wxFlexGridSizer,
22836 _swigc__p_wxFocusEvent,
22837 _swigc__p_wxFont,
22838 _swigc__p_wxFontData,
22839 _swigc__p_wxFontDialog,
22840 _swigc__p_wxFrame,
22841 _swigc__p_wxGBSizerItem,
22842 _swigc__p_wxGIFHandler,
22843 _swigc__p_wxGrid,
22844 _swigc__p_wxGridBagSizer,
22845 _swigc__p_wxGridCellAttr,
22846 _swigc__p_wxGridCellAttrProvider,
22847 _swigc__p_wxGridCellAutoWrapStringEditor,
22848 _swigc__p_wxGridCellAutoWrapStringRenderer,
22849 _swigc__p_wxGridCellBoolEditor,
22850 _swigc__p_wxGridCellBoolRenderer,
22851 _swigc__p_wxGridCellChoiceEditor,
22852 _swigc__p_wxGridCellCoords,
22853 _swigc__p_wxGridCellDateTimeRenderer,
22854 _swigc__p_wxGridCellEditor,
22855 _swigc__p_wxGridCellEnumEditor,
22856 _swigc__p_wxGridCellEnumRenderer,
22857 _swigc__p_wxGridCellFloatEditor,
22858 _swigc__p_wxGridCellFloatRenderer,
22859 _swigc__p_wxGridCellNumberEditor,
22860 _swigc__p_wxGridCellNumberRenderer,
22861 _swigc__p_wxGridCellRenderer,
22862 _swigc__p_wxGridCellStringRenderer,
22863 _swigc__p_wxGridCellTextEditor,
22864 _swigc__p_wxGridCellWorker,
22865 _swigc__p_wxGridEditorCreatedEvent,
22866 _swigc__p_wxGridEvent,
22867 _swigc__p_wxGridRangeSelectEvent,
22868 _swigc__p_wxGridSizeEvent,
22869 _swigc__p_wxGridSizer,
22870 _swigc__p_wxGridStringTable,
22871 _swigc__p_wxGridTableBase,
22872 _swigc__p_wxGridTableMessage,
22873 _swigc__p_wxICOHandler,
22874 _swigc__p_wxIconizeEvent,
22875 _swigc__p_wxIdleEvent,
22876 _swigc__p_wxImage,
22877 _swigc__p_wxImageHandler,
22878 _swigc__p_wxIndividualLayoutConstraint,
22879 _swigc__p_wxInitDialogEvent,
22880 _swigc__p_wxJPEGHandler,
22881 _swigc__p_wxKeyEvent,
22882 _swigc__p_wxLayoutAlgorithm,
22883 _swigc__p_wxLayoutConstraints,
22884 _swigc__p_wxMDIChildFrame,
22885 _swigc__p_wxMDIClientWindow,
22886 _swigc__p_wxMDIParentFrame,
22887 _swigc__p_wxMaximizeEvent,
22888 _swigc__p_wxMenu,
22889 _swigc__p_wxMenuBar,
22890 _swigc__p_wxMenuEvent,
22891 _swigc__p_wxMenuItem,
22892 _swigc__p_wxMessageDialog,
22893 _swigc__p_wxMiniFrame,
22894 _swigc__p_wxMouseCaptureChangedEvent,
22895 _swigc__p_wxMouseCaptureLostEvent,
22896 _swigc__p_wxMouseEvent,
22897 _swigc__p_wxMoveEvent,
22898 _swigc__p_wxMultiChoiceDialog,
22899 _swigc__p_wxNavigationKeyEvent,
22900 _swigc__p_wxNcPaintEvent,
22901 _swigc__p_wxNotifyEvent,
22902 _swigc__p_wxNumberEntryDialog,
22903 _swigc__p_wxObject,
22904 _swigc__p_wxPCXHandler,
22905 _swigc__p_wxPNGHandler,
22906 _swigc__p_wxPNMHandler,
22907 _swigc__p_wxPageSetupDialog,
22908 _swigc__p_wxPageSetupDialogData,
22909 _swigc__p_wxPaintEvent,
22910 _swigc__p_wxPaletteChangedEvent,
22911 _swigc__p_wxPanel,
22912 _swigc__p_wxPaperSize,
22913 _swigc__p_wxPasswordEntryDialog,
22914 _swigc__p_wxPen,
22915 _swigc__p_wxPoint,
22916 _swigc__p_wxPopupWindow,
22917 _swigc__p_wxPreviewCanvas,
22918 _swigc__p_wxPreviewControlBar,
22919 _swigc__p_wxPreviewFrame,
22920 _swigc__p_wxPrintData,
22921 _swigc__p_wxPrintDialog,
22922 _swigc__p_wxPrintDialogData,
22923 _swigc__p_wxPrintPreview,
22924 _swigc__p_wxPrinter,
22925 _swigc__p_wxProgressDialog,
22926 _swigc__p_wxPyApp,
22927 _swigc__p_wxPyCommandEvent,
22928 _swigc__p_wxPyEvent,
22929 _swigc__p_wxPyGridCellAttrProvider,
22930 _swigc__p_wxPyGridCellEditor,
22931 _swigc__p_wxPyGridCellRenderer,
22932 _swigc__p_wxPyGridTableBase,
22933 _swigc__p_wxPyHtmlListBox,
22934 _swigc__p_wxPyImageHandler,
22935 _swigc__p_wxPyPanel,
22936 _swigc__p_wxPyPopupTransientWindow,
22937 _swigc__p_wxPyPreviewControlBar,
22938 _swigc__p_wxPyPreviewFrame,
22939 _swigc__p_wxPyPrintPreview,
22940 _swigc__p_wxPyPrintout,
22941 _swigc__p_wxPyScrolledWindow,
22942 _swigc__p_wxPySizer,
22943 _swigc__p_wxPyTaskBarIcon,
22944 _swigc__p_wxPyVListBox,
22945 _swigc__p_wxPyVScrolledWindow,
22946 _swigc__p_wxPyValidator,
22947 _swigc__p_wxPyWindow,
22948 _swigc__p_wxQueryLayoutInfoEvent,
22949 _swigc__p_wxQueryNewPaletteEvent,
22950 _swigc__p_wxRect,
22951 _swigc__p_wxSashEvent,
22952 _swigc__p_wxSashLayoutWindow,
22953 _swigc__p_wxSashWindow,
22954 _swigc__p_wxScrollEvent,
22955 _swigc__p_wxScrollWinEvent,
22956 _swigc__p_wxScrolledWindow,
22957 _swigc__p_wxSetCursorEvent,
22958 _swigc__p_wxShowEvent,
22959 _swigc__p_wxSingleChoiceDialog,
22960 _swigc__p_wxSize,
22961 _swigc__p_wxSizeEvent,
22962 _swigc__p_wxSizer,
22963 _swigc__p_wxSizerItem,
22964 _swigc__p_wxSplashScreen,
22965 _swigc__p_wxSplashScreenWindow,
22966 _swigc__p_wxSplitterEvent,
22967 _swigc__p_wxSplitterWindow,
22968 _swigc__p_wxStaticBoxSizer,
22969 _swigc__p_wxStatusBar,
22970 _swigc__p_wxStdDialogButtonSizer,
22971 _swigc__p_wxString,
22972 _swigc__p_wxSysColourChangedEvent,
22973 _swigc__p_wxTIFFHandler,
22974 _swigc__p_wxTaskBarIconEvent,
22975 _swigc__p_wxTextEntryDialog,
22976 _swigc__p_wxTipWindow,
22977 _swigc__p_wxTopLevelWindow,
22978 _swigc__p_wxUpdateUIEvent,
22979 _swigc__p_wxValidator,
22980 _swigc__p_wxVisualAttributes,
22981 _swigc__p_wxWindow,
22982 _swigc__p_wxWindowCreateEvent,
22983 _swigc__p_wxWindowDestroyEvent,
22984 _swigc__p_wxXPMHandler,
22985 };
22986
22987
22988 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22989
22990 static swig_const_info swig_const_table[] = {
22991 {0, 0, 0, 0.0, 0, 0}};
22992
22993 #ifdef __cplusplus
22994 }
22995 #endif
22996 /* -----------------------------------------------------------------------------
22997 * Type initialization:
22998 * This problem is tough by the requirement that no dynamic
22999 * memory is used. Also, since swig_type_info structures store pointers to
23000 * swig_cast_info structures and swig_cast_info structures store pointers back
23001 * to swig_type_info structures, we need some lookup code at initialization.
23002 * The idea is that swig generates all the structures that are needed.
23003 * The runtime then collects these partially filled structures.
23004 * The SWIG_InitializeModule function takes these initial arrays out of
23005 * swig_module, and does all the lookup, filling in the swig_module.types
23006 * array with the correct data and linking the correct swig_cast_info
23007 * structures together.
23008 *
23009 * The generated swig_type_info structures are assigned staticly to an initial
23010 * array. We just loop though that array, and handle each type individually.
23011 * First we lookup if this type has been already loaded, and if so, use the
23012 * loaded structure instead of the generated one. Then we have to fill in the
23013 * cast linked list. The cast data is initially stored in something like a
23014 * two-dimensional array. Each row corresponds to a type (there are the same
23015 * number of rows as there are in the swig_type_initial array). Each entry in
23016 * a column is one of the swig_cast_info structures for that type.
23017 * The cast_initial array is actually an array of arrays, because each row has
23018 * a variable number of columns. So to actually build the cast linked list,
23019 * we find the array of casts associated with the type, and loop through it
23020 * adding the casts to the list. The one last trick we need to do is making
23021 * sure the type pointer in the swig_cast_info struct is correct.
23022 *
23023 * First off, we lookup the cast->type name to see if it is already loaded.
23024 * There are three cases to handle:
23025 * 1) If the cast->type has already been loaded AND the type we are adding
23026 * casting info to has not been loaded (it is in this module), THEN we
23027 * replace the cast->type pointer with the type pointer that has already
23028 * been loaded.
23029 * 2) If BOTH types (the one we are adding casting info to, and the
23030 * cast->type) are loaded, THEN the cast info has already been loaded by
23031 * the previous module so we just ignore it.
23032 * 3) Finally, if cast->type has not already been loaded, then we add that
23033 * swig_cast_info to the linked list (because the cast->type) pointer will
23034 * be correct.
23035 * ----------------------------------------------------------------------------- */
23036
23037 #ifdef __cplusplus
23038 extern "C" {
23039 #if 0
23040 } /* c-mode */
23041 #endif
23042 #endif
23043
23044 #if 0
23045 #define SWIGRUNTIME_DEBUG
23046 #endif
23047
23048 SWIGRUNTIME void
23049 SWIG_InitializeModule(void *clientdata) {
23050 size_t i;
23051 swig_module_info *module_head;
23052 static int init_run = 0;
23053
23054 clientdata = clientdata;
23055
23056 if (init_run) return;
23057 init_run = 1;
23058
23059 /* Initialize the swig_module */
23060 swig_module.type_initial = swig_type_initial;
23061 swig_module.cast_initial = swig_cast_initial;
23062
23063 /* Try and load any already created modules */
23064 module_head = SWIG_GetModule(clientdata);
23065 if (module_head) {
23066 swig_module.next = module_head->next;
23067 module_head->next = &swig_module;
23068 } else {
23069 /* This is the first module loaded */
23070 swig_module.next = &swig_module;
23071 SWIG_SetModule(clientdata, &swig_module);
23072 }
23073
23074 /* Now work on filling in swig_module.types */
23075 #ifdef SWIGRUNTIME_DEBUG
23076 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23077 #endif
23078 for (i = 0; i < swig_module.size; ++i) {
23079 swig_type_info *type = 0;
23080 swig_type_info *ret;
23081 swig_cast_info *cast;
23082
23083 #ifdef SWIGRUNTIME_DEBUG
23084 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23085 #endif
23086
23087 /* if there is another module already loaded */
23088 if (swig_module.next != &swig_module) {
23089 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23090 }
23091 if (type) {
23092 /* Overwrite clientdata field */
23093 #ifdef SWIGRUNTIME_DEBUG
23094 printf("SWIG_InitializeModule: found type %s\n", type->name);
23095 #endif
23096 if (swig_module.type_initial[i]->clientdata) {
23097 type->clientdata = swig_module.type_initial[i]->clientdata;
23098 #ifdef SWIGRUNTIME_DEBUG
23099 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23100 #endif
23101 }
23102 } else {
23103 type = swig_module.type_initial[i];
23104 }
23105
23106 /* Insert casting types */
23107 cast = swig_module.cast_initial[i];
23108 while (cast->type) {
23109 /* Don't need to add information already in the list */
23110 ret = 0;
23111 #ifdef SWIGRUNTIME_DEBUG
23112 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23113 #endif
23114 if (swig_module.next != &swig_module) {
23115 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23116 #ifdef SWIGRUNTIME_DEBUG
23117 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23118 #endif
23119 }
23120 if (ret) {
23121 if (type == swig_module.type_initial[i]) {
23122 #ifdef SWIGRUNTIME_DEBUG
23123 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23124 #endif
23125 cast->type = ret;
23126 ret = 0;
23127 } else {
23128 /* Check for casting already in the list */
23129 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23130 #ifdef SWIGRUNTIME_DEBUG
23131 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23132 #endif
23133 if (!ocast) ret = 0;
23134 }
23135 }
23136
23137 if (!ret) {
23138 #ifdef SWIGRUNTIME_DEBUG
23139 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23140 #endif
23141 if (type->cast) {
23142 type->cast->prev = cast;
23143 cast->next = type->cast;
23144 }
23145 type->cast = cast;
23146 }
23147 cast++;
23148 }
23149 /* Set entry in modules->types array equal to the type */
23150 swig_module.types[i] = type;
23151 }
23152 swig_module.types[i] = 0;
23153
23154 #ifdef SWIGRUNTIME_DEBUG
23155 printf("**** SWIG_InitializeModule: Cast List ******\n");
23156 for (i = 0; i < swig_module.size; ++i) {
23157 int j = 0;
23158 swig_cast_info *cast = swig_module.cast_initial[i];
23159 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23160 while (cast->type) {
23161 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23162 cast++;
23163 ++j;
23164 }
23165 printf("---- Total casts: %d\n",j);
23166 }
23167 printf("**** SWIG_InitializeModule: Cast List ******\n");
23168 #endif
23169 }
23170
23171 /* This function will propagate the clientdata field of type to
23172 * any new swig_type_info structures that have been added into the list
23173 * of equivalent types. It is like calling
23174 * SWIG_TypeClientData(type, clientdata) a second time.
23175 */
23176 SWIGRUNTIME void
23177 SWIG_PropagateClientData(void) {
23178 size_t i;
23179 swig_cast_info *equiv;
23180 static int init_run = 0;
23181
23182 if (init_run) return;
23183 init_run = 1;
23184
23185 for (i = 0; i < swig_module.size; i++) {
23186 if (swig_module.types[i]->clientdata) {
23187 equiv = swig_module.types[i]->cast;
23188 while (equiv) {
23189 if (!equiv->converter) {
23190 if (equiv->type && !equiv->type->clientdata)
23191 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23192 }
23193 equiv = equiv->next;
23194 }
23195 }
23196 }
23197 }
23198
23199 #ifdef __cplusplus
23200 #if 0
23201 {
23202 /* c-mode */
23203 #endif
23204 }
23205 #endif
23206
23207
23208
23209 #ifdef __cplusplus
23210 extern "C" {
23211 #endif
23212
23213 /* Python-specific SWIG API */
23214 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23215 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23216 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23217
23218 /* -----------------------------------------------------------------------------
23219 * global variable support code.
23220 * ----------------------------------------------------------------------------- */
23221
23222 typedef struct swig_globalvar {
23223 char *name; /* Name of global variable */
23224 PyObject *(*get_attr)(void); /* Return the current value */
23225 int (*set_attr)(PyObject *); /* Set the value */
23226 struct swig_globalvar *next;
23227 } swig_globalvar;
23228
23229 typedef struct swig_varlinkobject {
23230 PyObject_HEAD
23231 swig_globalvar *vars;
23232 } swig_varlinkobject;
23233
23234 SWIGINTERN PyObject *
23235 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23236 return PyString_FromString("<Swig global variables>");
23237 }
23238
23239 SWIGINTERN PyObject *
23240 swig_varlink_str(swig_varlinkobject *v) {
23241 PyObject *str = PyString_FromString("(");
23242 swig_globalvar *var;
23243 for (var = v->vars; var; var=var->next) {
23244 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23245 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23246 }
23247 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23248 return str;
23249 }
23250
23251 SWIGINTERN int
23252 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23253 PyObject *str = swig_varlink_str(v);
23254 fprintf(fp,"Swig global variables ");
23255 fprintf(fp,"%s\n", PyString_AsString(str));
23256 Py_DECREF(str);
23257 return 0;
23258 }
23259
23260 SWIGINTERN void
23261 swig_varlink_dealloc(swig_varlinkobject *v) {
23262 swig_globalvar *var = v->vars;
23263 while (var) {
23264 swig_globalvar *n = var->next;
23265 free(var->name);
23266 free(var);
23267 var = n;
23268 }
23269 }
23270
23271 SWIGINTERN PyObject *
23272 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23273 PyObject *res = NULL;
23274 swig_globalvar *var = v->vars;
23275 while (var) {
23276 if (strcmp(var->name,n) == 0) {
23277 res = (*var->get_attr)();
23278 break;
23279 }
23280 var = var->next;
23281 }
23282 if (res == NULL && !PyErr_Occurred()) {
23283 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23284 }
23285 return res;
23286 }
23287
23288 SWIGINTERN int
23289 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23290 int res = 1;
23291 swig_globalvar *var = v->vars;
23292 while (var) {
23293 if (strcmp(var->name,n) == 0) {
23294 res = (*var->set_attr)(p);
23295 break;
23296 }
23297 var = var->next;
23298 }
23299 if (res == 1 && !PyErr_Occurred()) {
23300 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23301 }
23302 return res;
23303 }
23304
23305 SWIGINTERN PyTypeObject*
23306 swig_varlink_type(void) {
23307 static char varlink__doc__[] = "Swig var link object";
23308 static PyTypeObject varlink_type;
23309 static int type_init = 0;
23310 if (!type_init) {
23311 const PyTypeObject tmp
23312 = {
23313 PyObject_HEAD_INIT(NULL)
23314 0, /* Number of items in variable part (ob_size) */
23315 (char *)"swigvarlink", /* Type name (tp_name) */
23316 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23317 0, /* Itemsize (tp_itemsize) */
23318 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23319 (printfunc) swig_varlink_print, /* Print (tp_print) */
23320 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23321 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23322 0, /* tp_compare */
23323 (reprfunc) swig_varlink_repr, /* tp_repr */
23324 0, /* tp_as_number */
23325 0, /* tp_as_sequence */
23326 0, /* tp_as_mapping */
23327 0, /* tp_hash */
23328 0, /* tp_call */
23329 (reprfunc)swig_varlink_str, /* tp_str */
23330 0, /* tp_getattro */
23331 0, /* tp_setattro */
23332 0, /* tp_as_buffer */
23333 0, /* tp_flags */
23334 varlink__doc__, /* tp_doc */
23335 0, /* tp_traverse */
23336 0, /* tp_clear */
23337 0, /* tp_richcompare */
23338 0, /* tp_weaklistoffset */
23339 #if PY_VERSION_HEX >= 0x02020000
23340 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23341 #endif
23342 #if PY_VERSION_HEX >= 0x02030000
23343 0, /* tp_del */
23344 #endif
23345 #ifdef COUNT_ALLOCS
23346 0,0,0,0 /* tp_alloc -> tp_next */
23347 #endif
23348 };
23349 varlink_type = tmp;
23350 varlink_type.ob_type = &PyType_Type;
23351 type_init = 1;
23352 }
23353 return &varlink_type;
23354 }
23355
23356 /* Create a variable linking object for use later */
23357 SWIGINTERN PyObject *
23358 SWIG_Python_newvarlink(void) {
23359 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23360 if (result) {
23361 result->vars = 0;
23362 }
23363 return ((PyObject*) result);
23364 }
23365
23366 SWIGINTERN void
23367 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23368 swig_varlinkobject *v = (swig_varlinkobject *) p;
23369 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23370 if (gv) {
23371 size_t size = strlen(name)+1;
23372 gv->name = (char *)malloc(size);
23373 if (gv->name) {
23374 strncpy(gv->name,name,size);
23375 gv->get_attr = get_attr;
23376 gv->set_attr = set_attr;
23377 gv->next = v->vars;
23378 }
23379 }
23380 v->vars = gv;
23381 }
23382
23383 SWIGINTERN PyObject *
23384 SWIG_globals() {
23385 static PyObject *_SWIG_globals = 0;
23386 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23387 return _SWIG_globals;
23388 }
23389
23390 /* -----------------------------------------------------------------------------
23391 * constants/methods manipulation
23392 * ----------------------------------------------------------------------------- */
23393
23394 /* Install Constants */
23395 SWIGINTERN void
23396 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23397 PyObject *obj = 0;
23398 size_t i;
23399 for (i = 0; constants[i].type; ++i) {
23400 switch(constants[i].type) {
23401 case SWIG_PY_POINTER:
23402 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23403 break;
23404 case SWIG_PY_BINARY:
23405 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23406 break;
23407 default:
23408 obj = 0;
23409 break;
23410 }
23411 if (obj) {
23412 PyDict_SetItemString(d, constants[i].name, obj);
23413 Py_DECREF(obj);
23414 }
23415 }
23416 }
23417
23418 /* -----------------------------------------------------------------------------*/
23419 /* Fix SwigMethods to carry the callback ptrs when needed */
23420 /* -----------------------------------------------------------------------------*/
23421
23422 SWIGINTERN void
23423 SWIG_Python_FixMethods(PyMethodDef *methods,
23424 swig_const_info *const_table,
23425 swig_type_info **types,
23426 swig_type_info **types_initial) {
23427 size_t i;
23428 for (i = 0; methods[i].ml_name; ++i) {
23429 const char *c = methods[i].ml_doc;
23430 if (c && (c = strstr(c, "swig_ptr: "))) {
23431 int j;
23432 swig_const_info *ci = 0;
23433 const char *name = c + 10;
23434 for (j = 0; const_table[j].type; ++j) {
23435 if (strncmp(const_table[j].name, name,
23436 strlen(const_table[j].name)) == 0) {
23437 ci = &(const_table[j]);
23438 break;
23439 }
23440 }
23441 if (ci) {
23442 size_t shift = (ci->ptype) - types;
23443 swig_type_info *ty = types_initial[shift];
23444 size_t ldoc = (c - methods[i].ml_doc);
23445 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23446 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23447 if (ndoc) {
23448 char *buff = ndoc;
23449 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23450 if (ptr) {
23451 strncpy(buff, methods[i].ml_doc, ldoc);
23452 buff += ldoc;
23453 strncpy(buff, "swig_ptr: ", 10);
23454 buff += 10;
23455 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23456 methods[i].ml_doc = ndoc;
23457 }
23458 }
23459 }
23460 }
23461 }
23462 }
23463
23464 #ifdef __cplusplus
23465 }
23466 #endif
23467
23468 /* -----------------------------------------------------------------------------*
23469 * Partial Init method
23470 * -----------------------------------------------------------------------------*/
23471
23472 #ifdef __cplusplus
23473 extern "C"
23474 #endif
23475 SWIGEXPORT void SWIG_init(void) {
23476 PyObject *m, *d;
23477
23478 /* Fix SwigMethods to carry the callback ptrs when needed */
23479 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23480
23481 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23482 d = PyModule_GetDict(m);
23483
23484 SWIG_InitializeModule(0);
23485 SWIG_InstallConstants(d,swig_const_table);
23486
23487
23488 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23489 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23490 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23491 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23492 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23493 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23494 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23495 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23496 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23497 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23498 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23499 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23500 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23501 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23502 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23503 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23504 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23505 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23506 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23507 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23508 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23509 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23510 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23511 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23512 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23513 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23514 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23515 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23516 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23517 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23518 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23519 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23520 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23521 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23522 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23523 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23524 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23525 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23526 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23527 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23528 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23529 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23530 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23531 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23532 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23533 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23534 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23535 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23536 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23537 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23538 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23539 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23540 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23541 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23542 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23543 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23544 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23545
23546
23547 }
23548
wxWidgets (Impactor)