]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added wxDialog::GetParentForModalDialog() and use it to try to always create modal...
[wxWidgets.git] / wxPython / src / gtk / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEventBlocker swig_types[34]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[35]
2502 #define SWIGTYPE_p_wxFSFile swig_types[36]
2503 #define SWIGTYPE_p_wxFileDialog swig_types[37]
2504 #define SWIGTYPE_p_wxFileSystem swig_types[38]
2505 #define SWIGTYPE_p_wxFindDialogEvent swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceData swig_types[40]
2507 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[41]
2508 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2509 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2510 #define SWIGTYPE_p_wxFont swig_types[44]
2511 #define SWIGTYPE_p_wxFontData swig_types[45]
2512 #define SWIGTYPE_p_wxFontDialog swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2516 #define SWIGTYPE_p_wxGrid swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttr swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellCoords swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[70]
2537 #define SWIGTYPE_p_wxGridCellWorker swig_types[71]
2538 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizeEvent swig_types[75]
2542 #define SWIGTYPE_p_wxGridSizer swig_types[76]
2543 #define SWIGTYPE_p_wxGridStringTable swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableBase swig_types[78]
2545 #define SWIGTYPE_p_wxGridTableMessage swig_types[79]
2546 #define SWIGTYPE_p_wxGridUpdateLocker swig_types[80]
2547 #define SWIGTYPE_p_wxICOHandler swig_types[81]
2548 #define SWIGTYPE_p_wxIconizeEvent swig_types[82]
2549 #define SWIGTYPE_p_wxIdleEvent swig_types[83]
2550 #define SWIGTYPE_p_wxImage swig_types[84]
2551 #define SWIGTYPE_p_wxImageHandler swig_types[85]
2552 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[86]
2553 #define SWIGTYPE_p_wxInitDialogEvent swig_types[87]
2554 #define SWIGTYPE_p_wxJPEGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxKeyEvent swig_types[89]
2556 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[90]
2557 #define SWIGTYPE_p_wxLayoutConstraints swig_types[91]
2558 #define SWIGTYPE_p_wxMDIChildFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMDIClientWindow swig_types[93]
2560 #define SWIGTYPE_p_wxMDIParentFrame swig_types[94]
2561 #define SWIGTYPE_p_wxMaximizeEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMenu swig_types[96]
2563 #define SWIGTYPE_p_wxMenuBar swig_types[97]
2564 #define SWIGTYPE_p_wxMenuEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMenuItem swig_types[99]
2566 #define SWIGTYPE_p_wxMessageDialog swig_types[100]
2567 #define SWIGTYPE_p_wxMiniFrame swig_types[101]
2568 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMouseEvent swig_types[104]
2571 #define SWIGTYPE_p_wxMoveEvent swig_types[105]
2572 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[106]
2573 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNcPaintEvent swig_types[108]
2575 #define SWIGTYPE_p_wxNotifyEvent swig_types[109]
2576 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[110]
2577 #define SWIGTYPE_p_wxObject swig_types[111]
2578 #define SWIGTYPE_p_wxPCXHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNGHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPNMHandler swig_types[114]
2581 #define SWIGTYPE_p_wxPageSetupDialog swig_types[115]
2582 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[116]
2583 #define SWIGTYPE_p_wxPaintEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPanel swig_types[119]
2586 #define SWIGTYPE_p_wxPaperSize swig_types[120]
2587 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[121]
2588 #define SWIGTYPE_p_wxPen swig_types[122]
2589 #define SWIGTYPE_p_wxPoint swig_types[123]
2590 #define SWIGTYPE_p_wxPopupWindow swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewCanvas swig_types[125]
2592 #define SWIGTYPE_p_wxPreviewControlBar swig_types[126]
2593 #define SWIGTYPE_p_wxPreviewFrame swig_types[127]
2594 #define SWIGTYPE_p_wxPrintData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintDialog swig_types[129]
2596 #define SWIGTYPE_p_wxPrintDialogData swig_types[130]
2597 #define SWIGTYPE_p_wxPrintPreview swig_types[131]
2598 #define SWIGTYPE_p_wxPrinter swig_types[132]
2599 #define SWIGTYPE_p_wxProgressDialog swig_types[133]
2600 #define SWIGTYPE_p_wxPyApp swig_types[134]
2601 #define SWIGTYPE_p_wxPyCommandEvent swig_types[135]
2602 #define SWIGTYPE_p_wxPyEvent swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[138]
2605 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[139]
2606 #define SWIGTYPE_p_wxPyGridTableBase swig_types[140]
2607 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[141]
2608 #define SWIGTYPE_p_wxPyImageHandler swig_types[142]
2609 #define SWIGTYPE_p_wxPyPanel swig_types[143]
2610 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[144]
2611 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[145]
2612 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[146]
2613 #define SWIGTYPE_p_wxPyPrintPreview swig_types[147]
2614 #define SWIGTYPE_p_wxPyPrintout swig_types[148]
2615 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[149]
2616 #define SWIGTYPE_p_wxPySizer swig_types[150]
2617 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[151]
2618 #define SWIGTYPE_p_wxPyVListBox swig_types[152]
2619 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[153]
2620 #define SWIGTYPE_p_wxPyValidator swig_types[154]
2621 #define SWIGTYPE_p_wxPyWindow swig_types[155]
2622 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[156]
2623 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[157]
2624 #define SWIGTYPE_p_wxRect swig_types[158]
2625 #define SWIGTYPE_p_wxSashEvent swig_types[159]
2626 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[160]
2627 #define SWIGTYPE_p_wxSashWindow swig_types[161]
2628 #define SWIGTYPE_p_wxScrollEvent swig_types[162]
2629 #define SWIGTYPE_p_wxScrollWinEvent swig_types[163]
2630 #define SWIGTYPE_p_wxScrolledWindow swig_types[164]
2631 #define SWIGTYPE_p_wxSetCursorEvent swig_types[165]
2632 #define SWIGTYPE_p_wxShowEvent swig_types[166]
2633 #define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[167]
2634 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[168]
2635 #define SWIGTYPE_p_wxSize swig_types[169]
2636 #define SWIGTYPE_p_wxSizeEvent swig_types[170]
2637 #define SWIGTYPE_p_wxSizer swig_types[171]
2638 #define SWIGTYPE_p_wxSizerItem swig_types[172]
2639 #define SWIGTYPE_p_wxSplashScreen swig_types[173]
2640 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[174]
2641 #define SWIGTYPE_p_wxSplitterEvent swig_types[175]
2642 #define SWIGTYPE_p_wxSplitterWindow swig_types[176]
2643 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[177]
2644 #define SWIGTYPE_p_wxStatusBar swig_types[178]
2645 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[179]
2646 #define SWIGTYPE_p_wxString swig_types[180]
2647 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[181]
2648 #define SWIGTYPE_p_wxTGAHandler swig_types[182]
2649 #define SWIGTYPE_p_wxTIFFHandler swig_types[183]
2650 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[184]
2651 #define SWIGTYPE_p_wxTextEntryDialog swig_types[185]
2652 #define SWIGTYPE_p_wxTipWindow swig_types[186]
2653 #define SWIGTYPE_p_wxTopLevelWindow swig_types[187]
2654 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[188]
2655 #define SWIGTYPE_p_wxValidator swig_types[189]
2656 #define SWIGTYPE_p_wxVisualAttributes swig_types[190]
2657 #define SWIGTYPE_p_wxWindow swig_types[191]
2658 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[192]
2659 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[193]
2660 #define SWIGTYPE_p_wxXPMHandler swig_types[194]
2661 static swig_type_info *swig_types[196];
2662 static swig_module_info swig_module = {swig_types, 195, 0, 0, 0, 0};
2663 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2664 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2665
2666 /* -------- TYPES TABLE (END) -------- */
2667
2668 #if (PY_VERSION_HEX <= 0x02000000)
2669 # if !defined(SWIG_PYTHON_CLASSIC)
2670 # error "This python version requires to use swig with the '-classic' option"
2671 # endif
2672 #endif
2673 #if (PY_VERSION_HEX <= 0x02020000)
2674 # error "This python version requires to use swig with the '-nomodern' option"
2675 #endif
2676 #if (PY_VERSION_HEX <= 0x02020000)
2677 # error "This python version requires to use swig with the '-nomodernargs' option"
2678 #endif
2679 #ifndef METH_O
2680 # error "This python version requires to use swig with the '-nofastunpack' option"
2681 #endif
2682
2683 /*-----------------------------------------------
2684 @(target):= _grid.so
2685 ------------------------------------------------*/
2686 #define SWIG_init init_grid
2687
2688 #define SWIG_name "_grid"
2689
2690 #define SWIGVERSION 0x010329
2691
2692
2693 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2694 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2695
2696
2697 #include <stdexcept>
2698
2699
2700 namespace swig {
2701 class PyObject_ptr {
2702 protected:
2703 PyObject *_obj;
2704
2705 public:
2706 PyObject_ptr() :_obj(0)
2707 {
2708 }
2709
2710 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2711 {
2712 Py_XINCREF(_obj);
2713 }
2714
2715 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2716 {
2717 if (initial_ref) Py_XINCREF(_obj);
2718 }
2719
2720 PyObject_ptr & operator=(const PyObject_ptr& item)
2721 {
2722 Py_XINCREF(item._obj);
2723 Py_XDECREF(_obj);
2724 _obj = item._obj;
2725 return *this;
2726 }
2727
2728 ~PyObject_ptr()
2729 {
2730 Py_XDECREF(_obj);
2731 }
2732
2733 operator PyObject *() const
2734 {
2735 return _obj;
2736 }
2737
2738 PyObject *operator->() const
2739 {
2740 return _obj;
2741 }
2742 };
2743 }
2744
2745
2746 namespace swig {
2747 struct PyObject_var : PyObject_ptr {
2748 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2749
2750 PyObject_var & operator = (PyObject* obj)
2751 {
2752 Py_XDECREF(_obj);
2753 _obj = obj;
2754 return *this;
2755 }
2756 };
2757 }
2758
2759
2760 #include "wx/wxPython/wxPython.h"
2761 #include "wx/wxPython/pyclasses.h"
2762 #include "wx/wxPython/printfw.h"
2763
2764 #include <wx/grid.h>
2765 #include <wx/generic/gridctrl.h>
2766
2767
2768 static const wxString wxPyEmptyString(wxEmptyString);
2769 static const wxString wxPyGridNameStr(wxGridNameStr);
2770 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2771
2772
2773 #define wxPyMake_TEMPLATE(TYPE) \
2774 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2775 PyObject* target = NULL; \
2776 if (source) { \
2777 /* Check if there is already a pointer to a Python object in the \
2778 OOR data that we can use. */ \
2779 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2780 if (data) { \
2781 target = data->m_obj; \
2782 if (target) \
2783 Py_INCREF(target); \
2784 } \
2785 /* Otherwise make a new wrapper for it the old fashioned way and \
2786 give it the OOR treatment */ \
2787 if (! target) { \
2788 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2789 if (target) \
2790 source->SetClientObject(new wxPyOORClientData(target)); \
2791 } \
2792 } else { /* source was NULL so return None. */ \
2793 Py_INCREF(Py_None); target = Py_None; \
2794 } \
2795 return target; \
2796 } \
2797
2798
2799 wxPyMake_TEMPLATE(wxGridCellRenderer)
2800 wxPyMake_TEMPLATE(wxGridCellEditor)
2801 wxPyMake_TEMPLATE(wxGridCellAttr)
2802 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2803 wxPyMake_TEMPLATE(wxGridTableBase)
2804
2805
2806
2807 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2808 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2809 wxGridCellAttr* rval = NULL; \
2810 bool found; \
2811 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2812 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2813 PyObject* ro; \
2814 wxGridCellAttr* ptr; \
2815 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2816 if (ro) { \
2817 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2818 rval = ptr; \
2819 Py_DECREF(ro); \
2820 } \
2821 } \
2822 wxPyEndBlockThreads(blocked); \
2823 if (! found) \
2824 rval = PCLASS::CBNAME(a, b, c); \
2825 return rval; \
2826 }
2827
2828
2829 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2830 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2832 bool found; \
2833 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2834 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2835 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2836 Py_DECREF(obj); \
2837 } \
2838 wxPyEndBlockThreads(blocked); \
2839 if (! found) \
2840 PCLASS::CBNAME(attr, a, b); \
2841 }
2842
2843
2844
2845 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2846 void CBNAME(wxGridCellAttr *attr, int val) { \
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2848 bool found; \
2849 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2850 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2851 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2852 Py_DECREF(obj); \
2853 } \
2854 wxPyEndBlockThreads(blocked); \
2855 if (! found) \
2856 PCLASS::CBNAME(attr, val); \
2857 }
2858
2859
2860
2861 #define PYCALLBACK_INT__pure(CBNAME) \
2862 int CBNAME() { \
2863 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2864 int rval = 0; \
2865 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2866 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2867 wxPyEndBlockThreads(blocked); \
2868 return rval; \
2869 }
2870
2871
2872
2873 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2874 bool CBNAME(int a, int b) { \
2875 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2876 bool rval = 0; \
2877 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2878 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2879 wxPyEndBlockThreads(blocked); \
2880 return rval; \
2881 }
2882
2883
2884 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2885 wxString CBNAME(int a, int b) { \
2886 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2887 wxString rval; \
2888 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2889 PyObject* ro; \
2890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2891 if (ro) { \
2892 rval = Py2wxString(ro); \
2893 Py_DECREF(ro); \
2894 } \
2895 } \
2896 wxPyEndBlockThreads(blocked); \
2897 return rval; \
2898 }
2899
2900
2901 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2902 void CBNAME(int a, int b, const wxString& c) { \
2903 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2904 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2905 PyObject* s = wx2PyString(c); \
2906 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2907 Py_DECREF(s); \
2908 } \
2909 wxPyEndBlockThreads(blocked); \
2910 }
2911
2912
2913 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2914 wxString CBNAME(int a, int b) { \
2915 bool found; \
2916 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2917 wxString rval; \
2918 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2919 PyObject* ro; \
2920 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2921 if (ro) { \
2922 rval = Py2wxString(ro); \
2923 Py_DECREF(ro); \
2924 } \
2925 } \
2926 wxPyEndBlockThreads(blocked); \
2927 if (! found) \
2928 rval = PCLASS::CBNAME(a, b); \
2929 return rval; \
2930 }
2931
2932
2933 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2934 bool CBNAME(int a, int b, const wxString& c) { \
2935 bool rval = 0; \
2936 bool found; \
2937 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2938 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2939 PyObject* s = wx2PyString(c); \
2940 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2941 Py_DECREF(s); \
2942 } \
2943 wxPyEndBlockThreads(blocked); \
2944 if (! found) \
2945 rval = PCLASS::CBNAME(a,b,c); \
2946 return rval; \
2947 }
2948
2949
2950
2951
2952 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2953 long CBNAME(int a, int b) { \
2954 long rval; \
2955 bool found; \
2956 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2957 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2958 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2959 wxPyEndBlockThreads(blocked); \
2960 if (! found) \
2961 rval = PCLASS::CBNAME(a,b); \
2962 return rval; \
2963 }
2964
2965
2966 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2967 bool CBNAME(int a, int b) { \
2968 bool rval = 0; \
2969 bool found; \
2970 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2971 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2972 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2973 wxPyEndBlockThreads(blocked); \
2974 if (! found) \
2975 rval = PCLASS::CBNAME(a,b); \
2976 return rval; \
2977 }
2978
2979
2980
2981 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2982 double CBNAME(int a, int b) { \
2983 bool found; \
2984 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2985 double rval; \
2986 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2987 PyObject* ro; \
2988 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2989 if (ro) { \
2990 PyObject* str = PyObject_Str(ro); \
2991 rval = PyFloat_AsDouble(str); \
2992 Py_DECREF(ro); Py_DECREF(str); \
2993 } \
2994 } \
2995 wxPyEndBlockThreads(blocked); \
2996 if (! found) \
2997 rval = PCLASS::CBNAME(a, b); \
2998 return rval; \
2999 }
3000
3001
3002
3003 #define PYCALLBACK__(PCLASS, CBNAME) \
3004 void CBNAME() { \
3005 bool found; \
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3007 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3008 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3009 wxPyEndBlockThreads(blocked); \
3010 if (! found) \
3011 PCLASS::CBNAME(); \
3012 }
3013
3014
3015
3016 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3017 bool CBNAME(size_t a, size_t b) { \
3018 bool rval = 0; \
3019 bool found; \
3020 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3021 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3022 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3023 wxPyEndBlockThreads(blocked); \
3024 if (! found) \
3025 rval = PCLASS::CBNAME(a,b); \
3026 return rval; \
3027 }
3028
3029
3030
3031 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3032 bool CBNAME(size_t a) { \
3033 bool rval = 0; \
3034 bool found; \
3035 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3036 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3037 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3038 wxPyEndBlockThreads(blocked); \
3039 if (! found) \
3040 rval = PCLASS::CBNAME(a); \
3041 return rval; \
3042 }
3043
3044
3045 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3046 wxString CBNAME(int a) { \
3047 bool found; \
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3049 wxString rval; \
3050 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3051 PyObject* ro; \
3052 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3053 if (ro) { \
3054 rval = Py2wxString(ro); \
3055 Py_DECREF(ro); \
3056 } \
3057 } \
3058 wxPyEndBlockThreads(blocked); \
3059 if (! found) \
3060 rval = PCLASS::CBNAME(a); \
3061 return rval; \
3062 }
3063
3064
3065 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3066 void CBNAME(int a, const wxString& c) { \
3067 bool found; \
3068 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3069 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3070 PyObject* s = wx2PyString(c); \
3071 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3072 Py_DECREF(s); \
3073 } \
3074 wxPyEndBlockThreads(blocked); \
3075 if (! found) \
3076 PCLASS::CBNAME(a,c); \
3077 }
3078
3079
3080
3081
3082 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3083 bool CBNAME() { \
3084 bool rval = 0; \
3085 bool found; \
3086 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3087 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3088 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3089 wxPyEndBlockThreads(blocked); \
3090 if (! found) \
3091 rval = PCLASS::CBNAME(); \
3092 return rval; \
3093 }
3094
3095
3096
3097 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3098 void CBNAME(size_t a, int b) { \
3099 bool found; \
3100 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3101 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3102 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3103 wxPyEndBlockThreads(blocked); \
3104 if (! found) \
3105 PCLASS::CBNAME(a,b); \
3106 }
3107
3108
3109
3110
3111 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3112 void CBNAME(int a, int b, long c) { \
3113 bool found; \
3114 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3115 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3116 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3117 wxPyEndBlockThreads(blocked); \
3118 if (! found) \
3119 PCLASS::CBNAME(a,b,c); \
3120 }
3121
3122
3123
3124
3125 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3126 void CBNAME(int a, int b, double c) { \
3127 bool found; \
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3129 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3130 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3131 wxPyEndBlockThreads(blocked); \
3132 if (! found) \
3133 PCLASS::CBNAME(a,b,c); \
3134 }
3135
3136
3137
3138 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3139 void CBNAME(int a, int b, bool c) { \
3140 bool found; \
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3142 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3143 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3144 wxPyEndBlockThreads(blocked); \
3145 if (! found) \
3146 PCLASS::CBNAME(a,b,c); \
3147 }
3148
3149
3150
3151
3152
3153 SWIGINTERN swig_type_info*
3154 SWIG_pchar_descriptor()
3155 {
3156 static int init = 0;
3157 static swig_type_info* info = 0;
3158 if (!init) {
3159 info = SWIG_TypeQuery("_p_char");
3160 init = 1;
3161 }
3162 return info;
3163 }
3164
3165
3166 SWIGINTERNINLINE PyObject *
3167 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3168 {
3169 if (carray) {
3170 if (size > INT_MAX) {
3171 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3172 return pchar_descriptor ?
3173 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3174 } else {
3175 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3176 }
3177 } else {
3178 return SWIG_Py_Void();
3179 }
3180 }
3181
3182
3183 SWIGINTERNINLINE PyObject *
3184 SWIG_FromCharPtr(const char *cptr)
3185 {
3186 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3187 }
3188
3189
3190 #define SWIG_From_long PyInt_FromLong
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_From_int (int value)
3195 {
3196 return SWIG_From_long (value);
3197 }
3198
3199
3200 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3201 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3202 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3203 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3204 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3205 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3206 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3207 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3208 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3209 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3210
3211 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3212 if (!self->GetClientObject())
3213 self->SetClientObject(new wxPyOORClientData(_self));
3214 }
3215 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3216 }
3217
3218 #include <limits.h>
3219 #ifndef LLONG_MIN
3220 # define LLONG_MIN LONG_LONG_MIN
3221 #endif
3222 #ifndef LLONG_MAX
3223 # define LLONG_MAX LONG_LONG_MAX
3224 #endif
3225 #ifndef ULLONG_MAX
3226 # define ULLONG_MAX ULONG_LONG_MAX
3227 #endif
3228
3229
3230 SWIGINTERN int
3231 SWIG_AsVal_long (PyObject* obj, long* val)
3232 {
3233 if (PyNumber_Check(obj)) {
3234 if (val) *val = PyInt_AsLong(obj);
3235 return SWIG_OK;
3236 }
3237 return SWIG_TypeError;
3238 }
3239
3240
3241 SWIGINTERN int
3242 SWIG_AsVal_int (PyObject * obj, int *val)
3243 {
3244 long v;
3245 int res = SWIG_AsVal_long (obj, &v);
3246 if (SWIG_IsOK(res)) {
3247 if ((v < INT_MIN || v > INT_MAX)) {
3248 return SWIG_OverflowError;
3249 } else {
3250 if (val) *val = static_cast< int >(v);
3251 }
3252 }
3253 return res;
3254 }
3255
3256
3257 SWIGINTERN int
3258 SWIG_AsVal_bool (PyObject *obj, bool *val)
3259 {
3260 if (obj == Py_True) {
3261 if (val) *val = true;
3262 return SWIG_OK;
3263 } else if (obj == Py_False) {
3264 if (val) *val = false;
3265 return SWIG_OK;
3266 } else {
3267 long v = 0;
3268 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3269 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3270 return res;
3271 }
3272 }
3273
3274
3275 class wxPyGridCellRenderer : public wxGridCellRenderer
3276 {
3277 public:
3278 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3279
3280 // Implement Python callback aware virtual methods
3281 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3282 wxDC& dc, const wxRect& rect,
3283 int row, int col, bool isSelected) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3286 PyObject* go = wxPyMake_wxObject(&grid,false);
3287 PyObject* dco = wxPyMake_wxObject(&dc,false);
3288 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3289 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3290
3291 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3292 row, col, isSelected));
3293 Py_DECREF(go);
3294 Py_DECREF(ao);
3295 Py_DECREF(dco);
3296 Py_DECREF(ro);
3297 }
3298 wxPyEndBlockThreads(blocked);
3299 }
3300
3301 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3302 int row, int col) {
3303 wxSize rval;
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3306 PyObject* ro;
3307 wxSize* ptr;
3308 PyObject* go = wxPyMake_wxObject(&grid,false);
3309 PyObject* dco = wxPyMake_wxObject(&dc,false);
3310 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3311
3312 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3313 go, ao, dco,
3314 row, col));
3315 Py_DECREF(go);
3316 Py_DECREF(ao);
3317 Py_DECREF(dco);
3318
3319 if (ro) {
3320 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3321 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3322 rval = *ptr;
3323 }
3324 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3325 PyErr_Clear(); // Clear the exception left over from wxPyConvertSwigPtr
3326 PyObject* o1 = PySequence_GetItem(ro, 0);
3327 PyObject* o2 = PySequence_GetItem(ro, 1);
3328 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3329 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3330 else
3331 PyErr_SetString(PyExc_TypeError, errmsg);
3332 Py_DECREF(o1);
3333 Py_DECREF(o2);
3334 }
3335 else {
3336 PyErr_SetString(PyExc_TypeError, errmsg);
3337 }
3338 Py_DECREF(ro);
3339 }
3340 }
3341 wxPyEndBlockThreads(blocked);
3342 return rval;
3343 }
3344
3345
3346 wxGridCellRenderer *Clone() const {
3347 wxGridCellRenderer* rval = NULL;
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3350 PyObject* ro;
3351 wxGridCellRenderer* ptr;
3352 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3353 if (ro) {
3354 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3355 rval = ptr;
3356 Py_DECREF(ro);
3357 }
3358 }
3359 wxPyEndBlockThreads(blocked);
3360 return rval;
3361 }
3362
3363 DEC_PYCALLBACK__STRING(SetParameters);
3364
3365 PYPRIVATE;
3366 };
3367
3368 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3369
3370
3371
3372 class wxPyGridCellEditor : public wxGridCellEditor
3373 {
3374 public:
3375 wxPyGridCellEditor() : wxGridCellEditor() {}
3376
3377 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3378 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3379 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3380 PyObject* po = wxPyMake_wxObject(parent,false);
3381 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3382
3383 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3384 Py_DECREF(po);
3385 Py_DECREF(eo);
3386 }
3387 wxPyEndBlockThreads(blocked);
3388 }
3389
3390
3391 void BeginEdit(int row, int col, wxGrid* grid) {
3392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3393 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3394 PyObject* go = wxPyMake_wxObject(grid,false);
3395 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3396 Py_DECREF(go);
3397 }
3398 wxPyEndBlockThreads(blocked);
3399 }
3400
3401
3402 bool EndEdit(int row, int col, wxGrid* grid) {
3403 bool rv = false;
3404 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3405 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3406 PyObject* go = wxPyMake_wxObject(grid,false);
3407 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3408 Py_DECREF(go);
3409 }
3410 wxPyEndBlockThreads(blocked);
3411 return rv;
3412 }
3413
3414
3415 wxGridCellEditor* Clone() const {
3416 wxGridCellEditor* rval = NULL;
3417 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3418 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3419 PyObject* ro;
3420 wxGridCellEditor* ptr;
3421 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3422 if (ro) {
3423 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3424 rval = ptr;
3425 Py_DECREF(ro);
3426 }
3427 }
3428 wxPyEndBlockThreads(blocked);
3429 return rval;
3430 }
3431
3432
3433 void Show(bool show, wxGridCellAttr *attr) {
3434 bool found;
3435 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3436 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3437 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3438 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3439 Py_DECREF(ao);
3440 }
3441 wxPyEndBlockThreads(blocked);
3442 if (! found)
3443 wxGridCellEditor::Show(show, attr);
3444 }
3445
3446
3447 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3448 bool found;
3449 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3450 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3451 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3452 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3453
3454 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3455
3456 Py_DECREF(ro);
3457 Py_DECREF(ao);
3458 }
3459 wxPyEndBlockThreads(blocked);
3460 if (! found)
3461 wxGridCellEditor::PaintBackground(rectCell, attr);
3462 }
3463
3464
3465 DEC_PYCALLBACK___pure(Reset);
3466 DEC_PYCALLBACK__constany(SetSize, wxRect);
3467 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3468 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3469 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3470 DEC_PYCALLBACK__(StartingClick);
3471 DEC_PYCALLBACK__(Destroy);
3472 DEC_PYCALLBACK__STRING(SetParameters);
3473 DEC_PYCALLBACK_STRING__constpure(GetValue);
3474
3475 PYPRIVATE;
3476 };
3477
3478
3479 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3480 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3481 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3482 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3483 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3484 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3485 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3486 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3487 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3488
3489
3490 static const wxString wxPyOneString(_T("1"));
3491 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3492 if (!self->GetClientObject())
3493 self->SetClientObject(new wxPyOORClientData(_self));
3494 }
3495 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3496 }
3497 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3498 if (!self->GetClientObject())
3499 self->SetClientObject(new wxPyOORClientData(_self));
3500 }
3501
3502 SWIGINTERN int
3503 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3504 {
3505 long v = 0;
3506 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3507 return SWIG_TypeError;
3508 }
3509 else if (val)
3510 *val = (unsigned long)v;
3511 return SWIG_OK;
3512 }
3513
3514
3515 SWIGINTERNINLINE int
3516 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3517 {
3518 unsigned long v;
3519 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3520 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3521 return res;
3522 }
3523
3524
3525 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3526 {
3527 public:
3528 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3529
3530 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3531 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3532 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3533 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3534
3535 PYPRIVATE;
3536 };
3537
3538 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3539 if (!self->GetClientObject())
3540 self->SetClientObject(new wxPyOORClientData(_self));
3541 }
3542
3543 #define SWIG_From_double PyFloat_FromDouble
3544
3545
3546 SWIGINTERN int
3547 SWIG_AsVal_double (PyObject *obj, double* val)
3548 {
3549 if (PyNumber_Check(obj)) {
3550 if (val) *val = PyFloat_AsDouble(obj);
3551 return SWIG_OK;
3552 }
3553 return SWIG_TypeError;
3554 }
3555
3556
3557 class wxPyGridTableBase : public wxGridTableBase
3558 {
3559 public:
3560 wxPyGridTableBase() : wxGridTableBase() {}
3561
3562 PYCALLBACK_INT__pure(GetNumberRows);
3563 PYCALLBACK_INT__pure(GetNumberCols);
3564 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3565 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3566 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3567 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3568 PYCALLBACK__(wxGridTableBase, Clear);
3569 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3570 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3571 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3572 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3573 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3574 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3575 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3576 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3577 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3578 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3579 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3580 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3581 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3582 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3583 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3584
3585
3586 wxString GetValue(int row, int col) {
3587 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3588 wxString rval;
3589 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3590 PyObject* ro;
3591 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3592 if (ro) {
3593 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3594 PyObject* old = ro;
3595 ro = PyObject_Str(ro);
3596 Py_DECREF(old);
3597 }
3598 rval = Py2wxString(ro);
3599 Py_DECREF(ro);
3600 }
3601 }
3602 wxPyEndBlockThreads(blocked);
3603 return rval;
3604 }
3605
3606 void SetValue(int row, int col, const wxString& val) {
3607 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3608 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3609 PyObject* s = wx2PyString(val);
3610 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3611 Py_DECREF(s);
3612 }
3613 wxPyEndBlockThreads(blocked);
3614 }
3615
3616
3617 // Map the Get/Set methods for the standard non-string types to
3618 // the GetValue and SetValue python methods.
3619 long GetValueAsLong( int row, int col ) {
3620 long rval = 0;
3621 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3622 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3623 PyObject* ro;
3624 PyObject* num;
3625 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3626 if (ro && PyNumber_Check(ro)) {
3627 num = PyNumber_Int(ro);
3628 if (num) {
3629 rval = PyInt_AsLong(num);
3630 Py_DECREF(num);
3631 }
3632 Py_DECREF(ro);
3633 }
3634 }
3635 wxPyEndBlockThreads(blocked);
3636 return rval;
3637 }
3638
3639 double GetValueAsDouble( int row, int col ) {
3640 double rval = 0.0;
3641 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3642 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3643 PyObject* ro;
3644 PyObject* num;
3645 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3646 if (ro && PyNumber_Check(ro)) {
3647 num = PyNumber_Float(ro);
3648 if (num) {
3649 rval = PyFloat_AsDouble(num);
3650 Py_DECREF(num);
3651 }
3652 Py_DECREF(ro);
3653 }
3654 }
3655 wxPyEndBlockThreads(blocked);
3656 return rval;
3657 }
3658
3659 bool GetValueAsBool( int row, int col ) {
3660 return (bool)GetValueAsLong(row, col);
3661 }
3662
3663 void SetValueAsLong( int row, int col, long value ) {
3664 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3665 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3666 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3667 }
3668 wxPyEndBlockThreads(blocked);
3669 }
3670
3671 void SetValueAsDouble( int row, int col, double value ) {
3672 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3673 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3674 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3675 }
3676 wxPyEndBlockThreads(blocked);
3677 }
3678
3679 void SetValueAsBool( int row, int col, bool value ) {
3680 SetValueAsLong( row, col, (long)value );
3681 }
3682
3683
3684 PYPRIVATE;
3685 };
3686
3687 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3688
3689 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3690
3691 if (source == Py_None) {
3692 **obj = wxGridCellCoords(-1,-1);
3693 return true;
3694 }
3695
3696 // If source is an object instance then it may already be the right type
3697 if (wxPySwigInstance_Check(source)) {
3698 wxGridCellCoords* ptr;
3699 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3700 goto error;
3701 *obj = ptr;
3702 return true;
3703 }
3704 // otherwise a 2-tuple of integers is expected
3705 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3706 PyObject* o1 = PySequence_GetItem(source, 0);
3707 PyObject* o2 = PySequence_GetItem(source, 1);
3708 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3709 Py_DECREF(o1);
3710 Py_DECREF(o2);
3711 goto error;
3712 }
3713 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3714 Py_DECREF(o1);
3715 Py_DECREF(o2);
3716 return true;
3717 }
3718
3719 error:
3720 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3721 return false;
3722 }
3723
3724
3725 bool wxGridCellCoords_typecheck(PyObject* source) {
3726 void* ptr;
3727
3728 if (wxPySwigInstance_Check(source) &&
3729 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3730 return true;
3731
3732 PyErr_Clear();
3733 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3734 return true;
3735
3736 return false;
3737 }
3738
3739
3740 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3741 {
3742 PyObject* list = PyList_New(0);
3743 size_t idx;
3744 for (idx = 0; idx < source.GetCount(); idx += 1) {
3745 wxGridCellCoords& coord = source.Item(idx);
3746 PyObject* tup = PyTuple_New(2);
3747 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3748 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3749 PyList_Append(list, tup);
3750 Py_DECREF(tup);
3751 }
3752 return list;
3753 }
3754
3755 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3756 wxGridCellCoords temp, *obj = &temp;
3757 if ( other == Py_None ) return false;
3758 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3759 PyErr_Clear();
3760 return false;
3761 }
3762 return self->operator==(*obj);
3763 }
3764 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3765 wxGridCellCoords temp, *obj = &temp;
3766 if ( other == Py_None ) return true;
3767 if ( ! wxGridCellCoords_helper(other, &obj)) {
3768 PyErr_Clear();
3769 return true;
3770 }
3771 return self->operator!=(*obj);
3772 }
3773 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3774 PyObject* tup = PyTuple_New(2);
3775 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3776 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3777 return tup;
3778 }
3779
3780 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3781
3782 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3783 wxGridCellCoords rv;
3784 self->XYToCell(x, y, rv);
3785 return rv;
3786 }
3787 #ifdef __cplusplus
3788 extern "C" {
3789 #endif
3790 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3791 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3792 return 1;
3793 }
3794
3795
3796 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3797 PyObject *pyobj = 0;
3798
3799 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3800 return pyobj;
3801 }
3802
3803
3804 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3805 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3806 return 1;
3807 }
3808
3809
3810 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3811 PyObject *pyobj = 0;
3812
3813 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3814 return pyobj;
3815 }
3816
3817
3818 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3819 PyObject *resultobj = 0;
3820 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3821 PyObject *arg2 = (PyObject *) 0 ;
3822 void *argp1 = 0 ;
3823 int res1 = 0 ;
3824 PyObject * obj0 = 0 ;
3825 PyObject * obj1 = 0 ;
3826 char * kwnames[] = {
3827 (char *) "self",(char *) "_self", NULL
3828 };
3829
3830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3832 if (!SWIG_IsOK(res1)) {
3833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3834 }
3835 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3836 arg2 = obj1;
3837 {
3838 PyThreadState* __tstate = wxPyBeginAllowThreads();
3839 wxGridCellWorker__setOORInfo(arg1,arg2);
3840 wxPyEndAllowThreads(__tstate);
3841 if (PyErr_Occurred()) SWIG_fail;
3842 }
3843 resultobj = SWIG_Py_Void();
3844 return resultobj;
3845 fail:
3846 return NULL;
3847 }
3848
3849
3850 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3851 PyObject *resultobj = 0;
3852 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3853 void *argp1 = 0 ;
3854 int res1 = 0 ;
3855 PyObject *swig_obj[1] ;
3856
3857 if (!args) SWIG_fail;
3858 swig_obj[0] = args;
3859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3860 if (!SWIG_IsOK(res1)) {
3861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3862 }
3863 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 delete_wxGridCellWorker(arg1);
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 resultobj = SWIG_Py_Void();
3872 return resultobj;
3873 fail:
3874 return NULL;
3875 }
3876
3877
3878 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3879 PyObject *resultobj = 0;
3880 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3881 wxString *arg2 = 0 ;
3882 void *argp1 = 0 ;
3883 int res1 = 0 ;
3884 bool temp2 = false ;
3885 PyObject * obj0 = 0 ;
3886 PyObject * obj1 = 0 ;
3887 char * kwnames[] = {
3888 (char *) "self",(char *) "params", NULL
3889 };
3890
3891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3893 if (!SWIG_IsOK(res1)) {
3894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3895 }
3896 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3897 {
3898 arg2 = wxString_in_helper(obj1);
3899 if (arg2 == NULL) SWIG_fail;
3900 temp2 = true;
3901 }
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 (arg1)->SetParameters((wxString const &)*arg2);
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 resultobj = SWIG_Py_Void();
3909 {
3910 if (temp2)
3911 delete arg2;
3912 }
3913 return resultobj;
3914 fail:
3915 {
3916 if (temp2)
3917 delete arg2;
3918 }
3919 return NULL;
3920 }
3921
3922
3923 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3924 PyObject *resultobj = 0;
3925 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3926 void *argp1 = 0 ;
3927 int res1 = 0 ;
3928 PyObject *swig_obj[1] ;
3929
3930 if (!args) SWIG_fail;
3931 swig_obj[0] = args;
3932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3933 if (!SWIG_IsOK(res1)) {
3934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3935 }
3936 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 (arg1)->IncRef();
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 resultobj = SWIG_Py_Void();
3944 return resultobj;
3945 fail:
3946 return NULL;
3947 }
3948
3949
3950 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3951 PyObject *resultobj = 0;
3952 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3953 void *argp1 = 0 ;
3954 int res1 = 0 ;
3955 PyObject *swig_obj[1] ;
3956
3957 if (!args) SWIG_fail;
3958 swig_obj[0] = args;
3959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3960 if (!SWIG_IsOK(res1)) {
3961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3962 }
3963 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 (arg1)->DecRef();
3967 wxPyEndAllowThreads(__tstate);
3968 if (PyErr_Occurred()) SWIG_fail;
3969 }
3970 resultobj = SWIG_Py_Void();
3971 return resultobj;
3972 fail:
3973 return NULL;
3974 }
3975
3976
3977 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3978 PyObject *obj;
3979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3980 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3981 return SWIG_Py_Void();
3982 }
3983
3984 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj = 0;
3986 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3987 wxGrid *arg2 = 0 ;
3988 wxGridCellAttr *arg3 = 0 ;
3989 wxDC *arg4 = 0 ;
3990 wxRect *arg5 = 0 ;
3991 int arg6 ;
3992 int arg7 ;
3993 bool arg8 ;
3994 void *argp1 = 0 ;
3995 int res1 = 0 ;
3996 void *argp2 = 0 ;
3997 int res2 = 0 ;
3998 void *argp3 = 0 ;
3999 int res3 = 0 ;
4000 void *argp4 = 0 ;
4001 int res4 = 0 ;
4002 wxRect temp5 ;
4003 int val6 ;
4004 int ecode6 = 0 ;
4005 int val7 ;
4006 int ecode7 = 0 ;
4007 bool val8 ;
4008 int ecode8 = 0 ;
4009 PyObject * obj0 = 0 ;
4010 PyObject * obj1 = 0 ;
4011 PyObject * obj2 = 0 ;
4012 PyObject * obj3 = 0 ;
4013 PyObject * obj4 = 0 ;
4014 PyObject * obj5 = 0 ;
4015 PyObject * obj6 = 0 ;
4016 PyObject * obj7 = 0 ;
4017 char * kwnames[] = {
4018 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4019 };
4020
4021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4023 if (!SWIG_IsOK(res1)) {
4024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4025 }
4026 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4027 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4028 if (!SWIG_IsOK(res2)) {
4029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4030 }
4031 if (!argp2) {
4032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4033 }
4034 arg2 = reinterpret_cast< wxGrid * >(argp2);
4035 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4036 if (!SWIG_IsOK(res3)) {
4037 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4038 }
4039 if (!argp3) {
4040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4041 }
4042 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4043 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4044 if (!SWIG_IsOK(res4)) {
4045 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4046 }
4047 if (!argp4) {
4048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4049 }
4050 arg4 = reinterpret_cast< wxDC * >(argp4);
4051 {
4052 arg5 = &temp5;
4053 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4054 }
4055 ecode6 = SWIG_AsVal_int(obj5, &val6);
4056 if (!SWIG_IsOK(ecode6)) {
4057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4058 }
4059 arg6 = static_cast< int >(val6);
4060 ecode7 = SWIG_AsVal_int(obj6, &val7);
4061 if (!SWIG_IsOK(ecode7)) {
4062 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4063 }
4064 arg7 = static_cast< int >(val7);
4065 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4066 if (!SWIG_IsOK(ecode8)) {
4067 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4068 }
4069 arg8 = static_cast< bool >(val8);
4070 {
4071 PyThreadState* __tstate = wxPyBeginAllowThreads();
4072 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4073 wxPyEndAllowThreads(__tstate);
4074 if (PyErr_Occurred()) SWIG_fail;
4075 }
4076 resultobj = SWIG_Py_Void();
4077 return resultobj;
4078 fail:
4079 return NULL;
4080 }
4081
4082
4083 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4084 PyObject *resultobj = 0;
4085 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4086 wxGrid *arg2 = 0 ;
4087 wxGridCellAttr *arg3 = 0 ;
4088 wxDC *arg4 = 0 ;
4089 int arg5 ;
4090 int arg6 ;
4091 wxSize result;
4092 void *argp1 = 0 ;
4093 int res1 = 0 ;
4094 void *argp2 = 0 ;
4095 int res2 = 0 ;
4096 void *argp3 = 0 ;
4097 int res3 = 0 ;
4098 void *argp4 = 0 ;
4099 int res4 = 0 ;
4100 int val5 ;
4101 int ecode5 = 0 ;
4102 int val6 ;
4103 int ecode6 = 0 ;
4104 PyObject * obj0 = 0 ;
4105 PyObject * obj1 = 0 ;
4106 PyObject * obj2 = 0 ;
4107 PyObject * obj3 = 0 ;
4108 PyObject * obj4 = 0 ;
4109 PyObject * obj5 = 0 ;
4110 char * kwnames[] = {
4111 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4112 };
4113
4114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4116 if (!SWIG_IsOK(res1)) {
4117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4118 }
4119 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4121 if (!SWIG_IsOK(res2)) {
4122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4123 }
4124 if (!argp2) {
4125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4126 }
4127 arg2 = reinterpret_cast< wxGrid * >(argp2);
4128 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4129 if (!SWIG_IsOK(res3)) {
4130 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4131 }
4132 if (!argp3) {
4133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4134 }
4135 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4136 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4137 if (!SWIG_IsOK(res4)) {
4138 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4139 }
4140 if (!argp4) {
4141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4142 }
4143 arg4 = reinterpret_cast< wxDC * >(argp4);
4144 ecode5 = SWIG_AsVal_int(obj4, &val5);
4145 if (!SWIG_IsOK(ecode5)) {
4146 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4147 }
4148 arg5 = static_cast< int >(val5);
4149 ecode6 = SWIG_AsVal_int(obj5, &val6);
4150 if (!SWIG_IsOK(ecode6)) {
4151 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4152 }
4153 arg6 = static_cast< int >(val6);
4154 {
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4168 PyObject *resultobj = 0;
4169 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4170 wxGridCellRenderer *result = 0 ;
4171 void *argp1 = 0 ;
4172 int res1 = 0 ;
4173 PyObject *swig_obj[1] ;
4174
4175 if (!args) SWIG_fail;
4176 swig_obj[0] = args;
4177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4178 if (!SWIG_IsOK(res1)) {
4179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4180 }
4181 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4182 {
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 {
4189 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4190 }
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4198 PyObject *obj;
4199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4200 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4201 return SWIG_Py_Void();
4202 }
4203
4204 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4205 PyObject *resultobj = 0;
4206 wxPyGridCellRenderer *result = 0 ;
4207
4208 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4209 {
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj = 0;
4224 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4225 PyObject *arg2 = (PyObject *) 0 ;
4226 PyObject *arg3 = (PyObject *) 0 ;
4227 void *argp1 = 0 ;
4228 int res1 = 0 ;
4229 PyObject * obj0 = 0 ;
4230 PyObject * obj1 = 0 ;
4231 PyObject * obj2 = 0 ;
4232 char * kwnames[] = {
4233 (char *) "self",(char *) "self",(char *) "_class", NULL
4234 };
4235
4236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4238 if (!SWIG_IsOK(res1)) {
4239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4240 }
4241 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4242 arg2 = obj1;
4243 arg3 = obj2;
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 (arg1)->_setCallbackInfo(arg2,arg3);
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_Py_Void();
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj = 0;
4259 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4260 wxString *arg2 = 0 ;
4261 void *argp1 = 0 ;
4262 int res1 = 0 ;
4263 bool temp2 = false ;
4264 PyObject * obj0 = 0 ;
4265 PyObject * obj1 = 0 ;
4266 char * kwnames[] = {
4267 (char *) "self",(char *) "params", NULL
4268 };
4269
4270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4272 if (!SWIG_IsOK(res1)) {
4273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4274 }
4275 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4276 {
4277 arg2 = wxString_in_helper(obj1);
4278 if (arg2 == NULL) SWIG_fail;
4279 temp2 = true;
4280 }
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 (arg1)->SetParameters((wxString const &)*arg2);
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 resultobj = SWIG_Py_Void();
4288 {
4289 if (temp2)
4290 delete arg2;
4291 }
4292 return resultobj;
4293 fail:
4294 {
4295 if (temp2)
4296 delete arg2;
4297 }
4298 return NULL;
4299 }
4300
4301
4302 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4303 PyObject *obj;
4304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4305 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4306 return SWIG_Py_Void();
4307 }
4308
4309 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4310 return SWIG_Python_InitShadowInstance(args);
4311 }
4312
4313 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4314 PyObject *resultobj = 0;
4315 wxGridCellStringRenderer *result = 0 ;
4316
4317 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4332 PyObject *obj;
4333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4334 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4335 return SWIG_Py_Void();
4336 }
4337
4338 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4339 return SWIG_Python_InitShadowInstance(args);
4340 }
4341
4342 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4343 PyObject *resultobj = 0;
4344 wxGridCellNumberRenderer *result = 0 ;
4345
4346 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4361 PyObject *obj;
4362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4363 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4364 return SWIG_Py_Void();
4365 }
4366
4367 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4368 return SWIG_Python_InitShadowInstance(args);
4369 }
4370
4371 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4372 PyObject *resultobj = 0;
4373 int arg1 = (int) -1 ;
4374 int arg2 = (int) -1 ;
4375 wxGridCellFloatRenderer *result = 0 ;
4376 int val1 ;
4377 int ecode1 = 0 ;
4378 int val2 ;
4379 int ecode2 = 0 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char * kwnames[] = {
4383 (char *) "width",(char *) "precision", NULL
4384 };
4385
4386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4387 if (obj0) {
4388 ecode1 = SWIG_AsVal_int(obj0, &val1);
4389 if (!SWIG_IsOK(ecode1)) {
4390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4391 }
4392 arg1 = static_cast< int >(val1);
4393 }
4394 if (obj1) {
4395 ecode2 = SWIG_AsVal_int(obj1, &val2);
4396 if (!SWIG_IsOK(ecode2)) {
4397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4398 }
4399 arg2 = static_cast< int >(val2);
4400 }
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4404 wxPyEndAllowThreads(__tstate);
4405 if (PyErr_Occurred()) SWIG_fail;
4406 }
4407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4408 return resultobj;
4409 fail:
4410 return NULL;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415 PyObject *resultobj = 0;
4416 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4417 int result;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4427 }
4428 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 resultobj = SWIG_From_int(static_cast< int >(result));
4436 return resultobj;
4437 fail:
4438 return NULL;
4439 }
4440
4441
4442 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj = 0;
4444 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4445 int arg2 ;
4446 void *argp1 = 0 ;
4447 int res1 = 0 ;
4448 int val2 ;
4449 int ecode2 = 0 ;
4450 PyObject * obj0 = 0 ;
4451 PyObject * obj1 = 0 ;
4452 char * kwnames[] = {
4453 (char *) "self",(char *) "width", NULL
4454 };
4455
4456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4460 }
4461 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4462 ecode2 = SWIG_AsVal_int(obj1, &val2);
4463 if (!SWIG_IsOK(ecode2)) {
4464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4465 }
4466 arg2 = static_cast< int >(val2);
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 (arg1)->SetWidth(arg2);
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 resultobj = SWIG_Py_Void();
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4483 int result;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 PyObject *swig_obj[1] ;
4487
4488 if (!args) SWIG_fail;
4489 swig_obj[0] = args;
4490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4491 if (!SWIG_IsOK(res1)) {
4492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4493 }
4494 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 resultobj = SWIG_From_int(static_cast< int >(result));
4502 return resultobj;
4503 fail:
4504 return NULL;
4505 }
4506
4507
4508 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4509 PyObject *resultobj = 0;
4510 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4511 int arg2 ;
4512 void *argp1 = 0 ;
4513 int res1 = 0 ;
4514 int val2 ;
4515 int ecode2 = 0 ;
4516 PyObject * obj0 = 0 ;
4517 PyObject * obj1 = 0 ;
4518 char * kwnames[] = {
4519 (char *) "self",(char *) "precision", NULL
4520 };
4521
4522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4524 if (!SWIG_IsOK(res1)) {
4525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4526 }
4527 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4528 ecode2 = SWIG_AsVal_int(obj1, &val2);
4529 if (!SWIG_IsOK(ecode2)) {
4530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4531 }
4532 arg2 = static_cast< int >(val2);
4533 {
4534 PyThreadState* __tstate = wxPyBeginAllowThreads();
4535 (arg1)->SetPrecision(arg2);
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 resultobj = SWIG_Py_Void();
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4547 PyObject *obj;
4548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4549 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4550 return SWIG_Py_Void();
4551 }
4552
4553 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 return SWIG_Python_InitShadowInstance(args);
4555 }
4556
4557 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4558 PyObject *resultobj = 0;
4559 wxGridCellBoolRenderer *result = 0 ;
4560
4561 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4569 return resultobj;
4570 fail:
4571 return NULL;
4572 }
4573
4574
4575 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4576 PyObject *obj;
4577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4578 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4579 return SWIG_Py_Void();
4580 }
4581
4582 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4583 return SWIG_Python_InitShadowInstance(args);
4584 }
4585
4586 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4589 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4590 wxGridCellDateTimeRenderer *result = 0 ;
4591 PyObject * obj0 = 0 ;
4592 PyObject * obj1 = 0 ;
4593 char * kwnames[] = {
4594 (char *) "outformat",(char *) "informat", NULL
4595 };
4596
4597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4598 if (obj0) {
4599 {
4600 wxString* sptr = wxString_in_helper(obj0);
4601 if (sptr == NULL) SWIG_fail;
4602 arg1 = *sptr;
4603 delete sptr;
4604 }
4605 }
4606 if (obj1) {
4607 {
4608 wxString* sptr = wxString_in_helper(obj1);
4609 if (sptr == NULL) SWIG_fail;
4610 arg2 = *sptr;
4611 delete sptr;
4612 }
4613 }
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628 PyObject *obj;
4629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4630 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4631 return SWIG_Py_Void();
4632 }
4633
4634 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4635 return SWIG_Python_InitShadowInstance(args);
4636 }
4637
4638 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxString const &arg1_defvalue = wxPyEmptyString ;
4641 wxString *arg1 = (wxString *) &arg1_defvalue ;
4642 wxGridCellEnumRenderer *result = 0 ;
4643 bool temp1 = false ;
4644 PyObject * obj0 = 0 ;
4645 char * kwnames[] = {
4646 (char *) "choices", NULL
4647 };
4648
4649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4650 if (obj0) {
4651 {
4652 arg1 = wxString_in_helper(obj0);
4653 if (arg1 == NULL) SWIG_fail;
4654 temp1 = true;
4655 }
4656 }
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4664 {
4665 if (temp1)
4666 delete arg1;
4667 }
4668 return resultobj;
4669 fail:
4670 {
4671 if (temp1)
4672 delete arg1;
4673 }
4674 return NULL;
4675 }
4676
4677
4678 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4679 PyObject *obj;
4680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4681 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4682 return SWIG_Py_Void();
4683 }
4684
4685 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4686 return SWIG_Python_InitShadowInstance(args);
4687 }
4688
4689 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4690 PyObject *resultobj = 0;
4691 wxGridCellAutoWrapStringRenderer *result = 0 ;
4692
4693 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4708 PyObject *obj;
4709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4710 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4711 return SWIG_Py_Void();
4712 }
4713
4714 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4715 return SWIG_Python_InitShadowInstance(args);
4716 }
4717
4718 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4719 PyObject *resultobj = 0;
4720 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4721 bool result;
4722 void *argp1 = 0 ;
4723 int res1 = 0 ;
4724 PyObject *swig_obj[1] ;
4725
4726 if (!args) SWIG_fail;
4727 swig_obj[0] = args;
4728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4729 if (!SWIG_IsOK(res1)) {
4730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4731 }
4732 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (bool)(arg1)->IsCreated();
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 {
4740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4741 }
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4749 PyObject *resultobj = 0;
4750 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4751 wxControl *result = 0 ;
4752 void *argp1 = 0 ;
4753 int res1 = 0 ;
4754 PyObject *swig_obj[1] ;
4755
4756 if (!args) SWIG_fail;
4757 swig_obj[0] = args;
4758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4759 if (!SWIG_IsOK(res1)) {
4760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4761 }
4762 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 result = (wxControl *)(arg1)->GetControl();
4766 wxPyEndAllowThreads(__tstate);
4767 if (PyErr_Occurred()) SWIG_fail;
4768 }
4769 {
4770 resultobj = wxPyMake_wxObject(result, 0);
4771 }
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj = 0;
4780 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4781 wxControl *arg2 = (wxControl *) 0 ;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 void *argp2 = 0 ;
4785 int res2 = 0 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 char * kwnames[] = {
4789 (char *) "self",(char *) "control", NULL
4790 };
4791
4792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4796 }
4797 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4799 if (!SWIG_IsOK(res2)) {
4800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4801 }
4802 arg2 = reinterpret_cast< wxControl * >(argp2);
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 (arg1)->SetControl(arg2);
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 resultobj = SWIG_Py_Void();
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4817 PyObject *resultobj = 0;
4818 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4819 wxGridCellAttr *result = 0 ;
4820 void *argp1 = 0 ;
4821 int res1 = 0 ;
4822 PyObject *swig_obj[1] ;
4823
4824 if (!args) SWIG_fail;
4825 swig_obj[0] = args;
4826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4827 if (!SWIG_IsOK(res1)) {
4828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4829 }
4830 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4831 {
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4834 wxPyEndAllowThreads(__tstate);
4835 if (PyErr_Occurred()) SWIG_fail;
4836 }
4837 {
4838 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4839 }
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj = 0;
4848 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4849 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 void *argp2 = 0 ;
4853 int res2 = 0 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char * kwnames[] = {
4857 (char *) "self",(char *) "attr", NULL
4858 };
4859
4860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4862 if (!SWIG_IsOK(res1)) {
4863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4864 }
4865 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4867 if (!SWIG_IsOK(res2)) {
4868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4869 }
4870 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4871 {
4872 PyThreadState* __tstate = wxPyBeginAllowThreads();
4873 (arg1)->SetCellAttr(arg2);
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 resultobj = SWIG_Py_Void();
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj = 0;
4886 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4887 wxWindow *arg2 = (wxWindow *) 0 ;
4888 int arg3 ;
4889 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4890 void *argp1 = 0 ;
4891 int res1 = 0 ;
4892 void *argp2 = 0 ;
4893 int res2 = 0 ;
4894 int val3 ;
4895 int ecode3 = 0 ;
4896 void *argp4 = 0 ;
4897 int res4 = 0 ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 PyObject * obj2 = 0 ;
4901 PyObject * obj3 = 0 ;
4902 char * kwnames[] = {
4903 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4904 };
4905
4906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4908 if (!SWIG_IsOK(res1)) {
4909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4910 }
4911 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4912 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4913 if (!SWIG_IsOK(res2)) {
4914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4915 }
4916 arg2 = reinterpret_cast< wxWindow * >(argp2);
4917 ecode3 = SWIG_AsVal_int(obj2, &val3);
4918 if (!SWIG_IsOK(ecode3)) {
4919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4920 }
4921 arg3 = static_cast< int >(val3);
4922 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4923 if (!SWIG_IsOK(res4)) {
4924 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4925 }
4926 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4927 {
4928 PyThreadState* __tstate = wxPyBeginAllowThreads();
4929 (arg1)->Create(arg2,arg3,arg4);
4930 wxPyEndAllowThreads(__tstate);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_Py_Void();
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj = 0;
4942 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4943 int arg2 ;
4944 int arg3 ;
4945 wxGrid *arg4 = (wxGrid *) 0 ;
4946 void *argp1 = 0 ;
4947 int res1 = 0 ;
4948 int val2 ;
4949 int ecode2 = 0 ;
4950 int val3 ;
4951 int ecode3 = 0 ;
4952 void *argp4 = 0 ;
4953 int res4 = 0 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 PyObject * obj2 = 0 ;
4957 PyObject * obj3 = 0 ;
4958 char * kwnames[] = {
4959 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4960 };
4961
4962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4966 }
4967 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4968 ecode2 = SWIG_AsVal_int(obj1, &val2);
4969 if (!SWIG_IsOK(ecode2)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4971 }
4972 arg2 = static_cast< int >(val2);
4973 ecode3 = SWIG_AsVal_int(obj2, &val3);
4974 if (!SWIG_IsOK(ecode3)) {
4975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4976 }
4977 arg3 = static_cast< int >(val3);
4978 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4979 if (!SWIG_IsOK(res4)) {
4980 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4981 }
4982 arg4 = reinterpret_cast< wxGrid * >(argp4);
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 (arg1)->BeginEdit(arg2,arg3,arg4);
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 resultobj = SWIG_Py_Void();
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj = 0;
4998 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4999 int arg2 ;
5000 int arg3 ;
5001 wxGrid *arg4 = (wxGrid *) 0 ;
5002 bool result;
5003 void *argp1 = 0 ;
5004 int res1 = 0 ;
5005 int val2 ;
5006 int ecode2 = 0 ;
5007 int val3 ;
5008 int ecode3 = 0 ;
5009 void *argp4 = 0 ;
5010 int res4 = 0 ;
5011 PyObject * obj0 = 0 ;
5012 PyObject * obj1 = 0 ;
5013 PyObject * obj2 = 0 ;
5014 PyObject * obj3 = 0 ;
5015 char * kwnames[] = {
5016 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5017 };
5018
5019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5021 if (!SWIG_IsOK(res1)) {
5022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5023 }
5024 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5025 ecode2 = SWIG_AsVal_int(obj1, &val2);
5026 if (!SWIG_IsOK(ecode2)) {
5027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5028 }
5029 arg2 = static_cast< int >(val2);
5030 ecode3 = SWIG_AsVal_int(obj2, &val3);
5031 if (!SWIG_IsOK(ecode3)) {
5032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5033 }
5034 arg3 = static_cast< int >(val3);
5035 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5036 if (!SWIG_IsOK(res4)) {
5037 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5038 }
5039 arg4 = reinterpret_cast< wxGrid * >(argp4);
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 {
5047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5056 PyObject *resultobj = 0;
5057 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5058 void *argp1 = 0 ;
5059 int res1 = 0 ;
5060 PyObject *swig_obj[1] ;
5061
5062 if (!args) SWIG_fail;
5063 swig_obj[0] = args;
5064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5065 if (!SWIG_IsOK(res1)) {
5066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5067 }
5068 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 (arg1)->Reset();
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 resultobj = SWIG_Py_Void();
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5083 PyObject *resultobj = 0;
5084 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5085 wxGridCellEditor *result = 0 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 PyObject *swig_obj[1] ;
5089
5090 if (!args) SWIG_fail;
5091 swig_obj[0] = args;
5092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5093 if (!SWIG_IsOK(res1)) {
5094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5095 }
5096 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj = 0;
5114 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5115 wxRect *arg2 = 0 ;
5116 void *argp1 = 0 ;
5117 int res1 = 0 ;
5118 wxRect temp2 ;
5119 PyObject * obj0 = 0 ;
5120 PyObject * obj1 = 0 ;
5121 char * kwnames[] = {
5122 (char *) "self",(char *) "rect", NULL
5123 };
5124
5125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5127 if (!SWIG_IsOK(res1)) {
5128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5129 }
5130 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5131 {
5132 arg2 = &temp2;
5133 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5134 }
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 (arg1)->SetSize((wxRect const &)*arg2);
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 resultobj = SWIG_Py_Void();
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj = 0;
5150 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5151 bool arg2 ;
5152 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5153 void *argp1 = 0 ;
5154 int res1 = 0 ;
5155 bool val2 ;
5156 int ecode2 = 0 ;
5157 void *argp3 = 0 ;
5158 int res3 = 0 ;
5159 PyObject * obj0 = 0 ;
5160 PyObject * obj1 = 0 ;
5161 PyObject * obj2 = 0 ;
5162 char * kwnames[] = {
5163 (char *) "self",(char *) "show",(char *) "attr", NULL
5164 };
5165
5166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5168 if (!SWIG_IsOK(res1)) {
5169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5170 }
5171 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5172 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5173 if (!SWIG_IsOK(ecode2)) {
5174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5175 }
5176 arg2 = static_cast< bool >(val2);
5177 if (obj2) {
5178 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5179 if (!SWIG_IsOK(res3)) {
5180 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5181 }
5182 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5183 }
5184 {
5185 PyThreadState* __tstate = wxPyBeginAllowThreads();
5186 (arg1)->Show(arg2,arg3);
5187 wxPyEndAllowThreads(__tstate);
5188 if (PyErr_Occurred()) SWIG_fail;
5189 }
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj = 0;
5199 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5200 wxRect *arg2 = 0 ;
5201 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5202 void *argp1 = 0 ;
5203 int res1 = 0 ;
5204 wxRect temp2 ;
5205 void *argp3 = 0 ;
5206 int res3 = 0 ;
5207 PyObject * obj0 = 0 ;
5208 PyObject * obj1 = 0 ;
5209 PyObject * obj2 = 0 ;
5210 char * kwnames[] = {
5211 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5212 };
5213
5214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5216 if (!SWIG_IsOK(res1)) {
5217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5218 }
5219 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5220 {
5221 arg2 = &temp2;
5222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5223 }
5224 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5225 if (!SWIG_IsOK(res3)) {
5226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5227 }
5228 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = 0;
5244 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5245 wxKeyEvent *arg2 = 0 ;
5246 bool result;
5247 void *argp1 = 0 ;
5248 int res1 = 0 ;
5249 void *argp2 = 0 ;
5250 int res2 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 char * kwnames[] = {
5254 (char *) "self",(char *) "event", NULL
5255 };
5256
5257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5259 if (!SWIG_IsOK(res1)) {
5260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5261 }
5262 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5264 if (!SWIG_IsOK(res2)) {
5265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5266 }
5267 if (!argp2) {
5268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5269 }
5270 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 {
5278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5279 }
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5287 PyObject *resultobj = 0;
5288 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5289 wxKeyEvent *arg2 = 0 ;
5290 void *argp1 = 0 ;
5291 int res1 = 0 ;
5292 void *argp2 = 0 ;
5293 int res2 = 0 ;
5294 PyObject * obj0 = 0 ;
5295 PyObject * obj1 = 0 ;
5296 char * kwnames[] = {
5297 (char *) "self",(char *) "event", NULL
5298 };
5299
5300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5302 if (!SWIG_IsOK(res1)) {
5303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5304 }
5305 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5307 if (!SWIG_IsOK(res2)) {
5308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5309 }
5310 if (!argp2) {
5311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5312 }
5313 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5314 {
5315 PyThreadState* __tstate = wxPyBeginAllowThreads();
5316 (arg1)->StartingKey(*arg2);
5317 wxPyEndAllowThreads(__tstate);
5318 if (PyErr_Occurred()) SWIG_fail;
5319 }
5320 resultobj = SWIG_Py_Void();
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5330 void *argp1 = 0 ;
5331 int res1 = 0 ;
5332 PyObject *swig_obj[1] ;
5333
5334 if (!args) SWIG_fail;
5335 swig_obj[0] = args;
5336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5337 if (!SWIG_IsOK(res1)) {
5338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5339 }
5340 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 (arg1)->StartingClick();
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 resultobj = SWIG_Py_Void();
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5355 PyObject *resultobj = 0;
5356 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5357 wxKeyEvent *arg2 = 0 ;
5358 void *argp1 = 0 ;
5359 int res1 = 0 ;
5360 void *argp2 = 0 ;
5361 int res2 = 0 ;
5362 PyObject * obj0 = 0 ;
5363 PyObject * obj1 = 0 ;
5364 char * kwnames[] = {
5365 (char *) "self",(char *) "event", NULL
5366 };
5367
5368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5370 if (!SWIG_IsOK(res1)) {
5371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5372 }
5373 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5375 if (!SWIG_IsOK(res2)) {
5376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5377 }
5378 if (!argp2) {
5379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5380 }
5381 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 (arg1)->HandleReturn(*arg2);
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 resultobj = SWIG_Py_Void();
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396 PyObject *resultobj = 0;
5397 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5398 void *argp1 = 0 ;
5399 int res1 = 0 ;
5400 PyObject *swig_obj[1] ;
5401
5402 if (!args) SWIG_fail;
5403 swig_obj[0] = args;
5404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5405 if (!SWIG_IsOK(res1)) {
5406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5407 }
5408 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 (arg1)->Destroy();
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 resultobj = SWIG_Py_Void();
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423 PyObject *obj;
5424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5425 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5426 return SWIG_Py_Void();
5427 }
5428
5429 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5430 PyObject *resultobj = 0;
5431 wxPyGridCellEditor *result = 0 ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj = 0;
5449 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5450 PyObject *arg2 = (PyObject *) 0 ;
5451 PyObject *arg3 = (PyObject *) 0 ;
5452 void *argp1 = 0 ;
5453 int res1 = 0 ;
5454 PyObject * obj0 = 0 ;
5455 PyObject * obj1 = 0 ;
5456 PyObject * obj2 = 0 ;
5457 char * kwnames[] = {
5458 (char *) "self",(char *) "self",(char *) "_class", NULL
5459 };
5460
5461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5463 if (!SWIG_IsOK(res1)) {
5464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5465 }
5466 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5467 arg2 = obj1;
5468 arg3 = obj2;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 (arg1)->_setCallbackInfo(arg2,arg3);
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_Py_Void();
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5483 PyObject *resultobj = 0;
5484 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5485 wxString *arg2 = 0 ;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 bool temp2 = false ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "params", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5499 }
5500 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5501 {
5502 arg2 = wxString_in_helper(obj1);
5503 if (arg2 == NULL) SWIG_fail;
5504 temp2 = true;
5505 }
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 (arg1)->SetParameters((wxString const &)*arg2);
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 resultobj = SWIG_Py_Void();
5513 {
5514 if (temp2)
5515 delete arg2;
5516 }
5517 return resultobj;
5518 fail:
5519 {
5520 if (temp2)
5521 delete arg2;
5522 }
5523 return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5528 PyObject *obj;
5529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5530 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5531 return SWIG_Py_Void();
5532 }
5533
5534 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5535 return SWIG_Python_InitShadowInstance(args);
5536 }
5537
5538 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5539 PyObject *resultobj = 0;
5540 wxGridCellTextEditor *result = 0 ;
5541
5542 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5543 {
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5557 PyObject *resultobj = 0;
5558 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5559 wxString result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject *swig_obj[1] ;
5563
5564 if (!args) SWIG_fail;
5565 swig_obj[0] = args;
5566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5567 if (!SWIG_IsOK(res1)) {
5568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5569 }
5570 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5571 {
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (arg1)->GetValue();
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 {
5578 #if wxUSE_UNICODE
5579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5580 #else
5581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5582 #endif
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5591 PyObject *obj;
5592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5593 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5594 return SWIG_Py_Void();
5595 }
5596
5597 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5598 return SWIG_Python_InitShadowInstance(args);
5599 }
5600
5601 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj = 0;
5603 int arg1 = (int) -1 ;
5604 int arg2 = (int) -1 ;
5605 wxGridCellNumberEditor *result = 0 ;
5606 int val1 ;
5607 int ecode1 = 0 ;
5608 int val2 ;
5609 int ecode2 = 0 ;
5610 PyObject * obj0 = 0 ;
5611 PyObject * obj1 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "min",(char *) "max", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5617 if (obj0) {
5618 ecode1 = SWIG_AsVal_int(obj0, &val1);
5619 if (!SWIG_IsOK(ecode1)) {
5620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5621 }
5622 arg1 = static_cast< int >(val1);
5623 }
5624 if (obj1) {
5625 ecode2 = SWIG_AsVal_int(obj1, &val2);
5626 if (!SWIG_IsOK(ecode2)) {
5627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5628 }
5629 arg2 = static_cast< int >(val2);
5630 }
5631 {
5632 PyThreadState* __tstate = wxPyBeginAllowThreads();
5633 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5634 wxPyEndAllowThreads(__tstate);
5635 if (PyErr_Occurred()) SWIG_fail;
5636 }
5637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5638 return resultobj;
5639 fail:
5640 return NULL;
5641 }
5642
5643
5644 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5645 PyObject *obj;
5646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5647 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5648 return SWIG_Py_Void();
5649 }
5650
5651 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5652 return SWIG_Python_InitShadowInstance(args);
5653 }
5654
5655 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj = 0;
5657 int arg1 = (int) -1 ;
5658 int arg2 = (int) -1 ;
5659 wxGridCellFloatEditor *result = 0 ;
5660 int val1 ;
5661 int ecode1 = 0 ;
5662 int val2 ;
5663 int ecode2 = 0 ;
5664 PyObject * obj0 = 0 ;
5665 PyObject * obj1 = 0 ;
5666 char * kwnames[] = {
5667 (char *) "width",(char *) "precision", NULL
5668 };
5669
5670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5671 if (obj0) {
5672 ecode1 = SWIG_AsVal_int(obj0, &val1);
5673 if (!SWIG_IsOK(ecode1)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5675 }
5676 arg1 = static_cast< int >(val1);
5677 }
5678 if (obj1) {
5679 ecode2 = SWIG_AsVal_int(obj1, &val2);
5680 if (!SWIG_IsOK(ecode2)) {
5681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5682 }
5683 arg2 = static_cast< int >(val2);
5684 }
5685 {
5686 PyThreadState* __tstate = wxPyBeginAllowThreads();
5687 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5699 PyObject *obj;
5700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5701 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5702 return SWIG_Py_Void();
5703 }
5704
5705 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5706 return SWIG_Python_InitShadowInstance(args);
5707 }
5708
5709 SWIGINTERN int OneString_set(PyObject *) {
5710 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5711 return 1;
5712 }
5713
5714
5715 SWIGINTERN PyObject *OneString_get(void) {
5716 PyObject *pyobj = 0;
5717
5718 {
5719 #if wxUSE_UNICODE
5720 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5721 #else
5722 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5723 #endif
5724 }
5725 return pyobj;
5726 }
5727
5728
5729 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *resultobj = 0;
5731 wxGridCellBoolEditor *result = 0 ;
5732
5733 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5734 {
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj = 0;
5749 wxString const &arg1_defvalue = wxPyOneString ;
5750 wxString *arg1 = (wxString *) &arg1_defvalue ;
5751 wxString const &arg2_defvalue = wxPyEmptyString ;
5752 wxString *arg2 = (wxString *) &arg2_defvalue ;
5753 bool temp1 = false ;
5754 bool temp2 = false ;
5755 PyObject * obj0 = 0 ;
5756 PyObject * obj1 = 0 ;
5757 char * kwnames[] = {
5758 (char *) "valueTrue",(char *) "valueFalse", NULL
5759 };
5760
5761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5762 if (obj0) {
5763 {
5764 arg1 = wxString_in_helper(obj0);
5765 if (arg1 == NULL) SWIG_fail;
5766 temp1 = true;
5767 }
5768 }
5769 if (obj1) {
5770 {
5771 arg2 = wxString_in_helper(obj1);
5772 if (arg2 == NULL) SWIG_fail;
5773 temp2 = true;
5774 }
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 resultobj = SWIG_Py_Void();
5783 {
5784 if (temp1)
5785 delete arg1;
5786 }
5787 {
5788 if (temp2)
5789 delete arg2;
5790 }
5791 return resultobj;
5792 fail:
5793 {
5794 if (temp1)
5795 delete arg1;
5796 }
5797 {
5798 if (temp2)
5799 delete arg2;
5800 }
5801 return NULL;
5802 }
5803
5804
5805 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj = 0;
5807 wxString *arg1 = 0 ;
5808 bool result;
5809 bool temp1 = false ;
5810 PyObject * obj0 = 0 ;
5811 char * kwnames[] = {
5812 (char *) "value", NULL
5813 };
5814
5815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5816 {
5817 arg1 = wxString_in_helper(obj0);
5818 if (arg1 == NULL) SWIG_fail;
5819 temp1 = true;
5820 }
5821 {
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 {
5828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5829 }
5830 {
5831 if (temp1)
5832 delete arg1;
5833 }
5834 return resultobj;
5835 fail:
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5845 PyObject *obj;
5846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5847 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5848 return SWIG_Py_Void();
5849 }
5850
5851 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852 return SWIG_Python_InitShadowInstance(args);
5853 }
5854
5855 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj = 0;
5857 int arg1 = (int) 0 ;
5858 wxString *arg2 = (wxString *) NULL ;
5859 bool arg3 = (bool) false ;
5860 wxGridCellChoiceEditor *result = 0 ;
5861 bool val3 ;
5862 int ecode3 = 0 ;
5863 PyObject * obj0 = 0 ;
5864 PyObject * obj1 = 0 ;
5865 char * kwnames[] = {
5866 (char *) "choices",(char *) "allowOthers", NULL
5867 };
5868
5869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5870 if (obj0) {
5871 {
5872 arg1 = PyList_Size(obj0);
5873 arg2 = wxString_LIST_helper(obj0);
5874 if (arg2 == NULL) SWIG_fail;
5875 }
5876 }
5877 if (obj1) {
5878 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5879 if (!SWIG_IsOK(ecode3)) {
5880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5881 }
5882 arg3 = static_cast< bool >(val3);
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5887 wxPyEndAllowThreads(__tstate);
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5891 {
5892 if (arg2) delete [] arg2;
5893 }
5894 return resultobj;
5895 fail:
5896 {
5897 if (arg2) delete [] arg2;
5898 }
5899 return NULL;
5900 }
5901
5902
5903 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5904 PyObject *obj;
5905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5906 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5907 return SWIG_Py_Void();
5908 }
5909
5910 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5911 return SWIG_Python_InitShadowInstance(args);
5912 }
5913
5914 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5915 PyObject *resultobj = 0;
5916 wxString const &arg1_defvalue = wxPyEmptyString ;
5917 wxString *arg1 = (wxString *) &arg1_defvalue ;
5918 wxGridCellEnumEditor *result = 0 ;
5919 bool temp1 = false ;
5920 PyObject * obj0 = 0 ;
5921 char * kwnames[] = {
5922 (char *) "choices", NULL
5923 };
5924
5925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5926 if (obj0) {
5927 {
5928 arg1 = wxString_in_helper(obj0);
5929 if (arg1 == NULL) SWIG_fail;
5930 temp1 = true;
5931 }
5932 }
5933 {
5934 PyThreadState* __tstate = wxPyBeginAllowThreads();
5935 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5936 wxPyEndAllowThreads(__tstate);
5937 if (PyErr_Occurred()) SWIG_fail;
5938 }
5939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 return resultobj;
5945 fail:
5946 {
5947 if (temp1)
5948 delete arg1;
5949 }
5950 return NULL;
5951 }
5952
5953
5954 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5955 PyObject *obj;
5956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5957 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5958 return SWIG_Py_Void();
5959 }
5960
5961 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 return SWIG_Python_InitShadowInstance(args);
5963 }
5964
5965 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5966 PyObject *resultobj = 0;
5967 wxGridCellAutoWrapStringEditor *result = 0 ;
5968
5969 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5984 PyObject *obj;
5985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5986 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5987 return SWIG_Py_Void();
5988 }
5989
5990 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5991 return SWIG_Python_InitShadowInstance(args);
5992 }
5993
5994 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = 0;
5996 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5997 PyObject *arg2 = (PyObject *) 0 ;
5998 void *argp1 = 0 ;
5999 int res1 = 0 ;
6000 PyObject * obj0 = 0 ;
6001 PyObject * obj1 = 0 ;
6002 char * kwnames[] = {
6003 (char *) "self",(char *) "_self", NULL
6004 };
6005
6006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6008 if (!SWIG_IsOK(res1)) {
6009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6010 }
6011 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6012 arg2 = obj1;
6013 {
6014 PyThreadState* __tstate = wxPyBeginAllowThreads();
6015 wxGridCellAttr__setOORInfo(arg1,arg2);
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 resultobj = SWIG_Py_Void();
6020 return resultobj;
6021 fail:
6022 return NULL;
6023 }
6024
6025
6026 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6027 PyObject *resultobj = 0;
6028 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6029 wxGridCellAttr *result = 0 ;
6030 void *argp1 = 0 ;
6031 int res1 = 0 ;
6032 PyObject * obj0 = 0 ;
6033 char * kwnames[] = {
6034 (char *) "attrDefault", NULL
6035 };
6036
6037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6038 if (obj0) {
6039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6040 if (!SWIG_IsOK(res1)) {
6041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6042 }
6043 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6044 }
6045 {
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6053 }
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *resultobj = 0;
6062 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6063 void *argp1 = 0 ;
6064 int res1 = 0 ;
6065 PyObject *swig_obj[1] ;
6066
6067 if (!args) SWIG_fail;
6068 swig_obj[0] = args;
6069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6070 if (!SWIG_IsOK(res1)) {
6071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6072 }
6073 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6074 {
6075 PyThreadState* __tstate = wxPyBeginAllowThreads();
6076 delete_wxGridCellAttr(arg1);
6077
6078 wxPyEndAllowThreads(__tstate);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 resultobj = SWIG_Py_Void();
6082 return resultobj;
6083 fail:
6084 return NULL;
6085 }
6086
6087
6088 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6089 PyObject *resultobj = 0;
6090 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6091 wxGridCellAttr *result = 0 ;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 PyObject *swig_obj[1] ;
6095
6096 if (!args) SWIG_fail;
6097 swig_obj[0] = args;
6098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6099 if (!SWIG_IsOK(res1)) {
6100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6101 }
6102 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 {
6110 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6111 }
6112 return resultobj;
6113 fail:
6114 return NULL;
6115 }
6116
6117
6118 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj = 0;
6120 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6121 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6122 void *argp1 = 0 ;
6123 int res1 = 0 ;
6124 void *argp2 = 0 ;
6125 int res2 = 0 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char * kwnames[] = {
6129 (char *) "self",(char *) "mergefrom", NULL
6130 };
6131
6132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6134 if (!SWIG_IsOK(res1)) {
6135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6136 }
6137 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6139 if (!SWIG_IsOK(res2)) {
6140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6141 }
6142 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6143 {
6144 PyThreadState* __tstate = wxPyBeginAllowThreads();
6145 (arg1)->MergeWith(arg2);
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = SWIG_Py_Void();
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6157 PyObject *resultobj = 0;
6158 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6159 void *argp1 = 0 ;
6160 int res1 = 0 ;
6161 PyObject *swig_obj[1] ;
6162
6163 if (!args) SWIG_fail;
6164 swig_obj[0] = args;
6165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6166 if (!SWIG_IsOK(res1)) {
6167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6168 }
6169 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 (arg1)->IncRef();
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 resultobj = SWIG_Py_Void();
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6184 PyObject *resultobj = 0;
6185 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6186 void *argp1 = 0 ;
6187 int res1 = 0 ;
6188 PyObject *swig_obj[1] ;
6189
6190 if (!args) SWIG_fail;
6191 swig_obj[0] = args;
6192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6193 if (!SWIG_IsOK(res1)) {
6194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6195 }
6196 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 (arg1)->DecRef();
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 resultobj = SWIG_Py_Void();
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj = 0;
6212 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6213 wxColour *arg2 = 0 ;
6214 void *argp1 = 0 ;
6215 int res1 = 0 ;
6216 wxColour temp2 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 char * kwnames[] = {
6220 (char *) "self",(char *) "colText", NULL
6221 };
6222
6223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6225 if (!SWIG_IsOK(res1)) {
6226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6227 }
6228 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6229 {
6230 arg2 = &temp2;
6231 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6232 }
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 (arg1)->SetTextColour((wxColour const &)*arg2);
6236 wxPyEndAllowThreads(__tstate);
6237 if (PyErr_Occurred()) SWIG_fail;
6238 }
6239 resultobj = SWIG_Py_Void();
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj = 0;
6248 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6249 wxColour *arg2 = 0 ;
6250 void *argp1 = 0 ;
6251 int res1 = 0 ;
6252 wxColour temp2 ;
6253 PyObject * obj0 = 0 ;
6254 PyObject * obj1 = 0 ;
6255 char * kwnames[] = {
6256 (char *) "self",(char *) "colBack", NULL
6257 };
6258
6259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6261 if (!SWIG_IsOK(res1)) {
6262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6263 }
6264 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6265 {
6266 arg2 = &temp2;
6267 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6268 }
6269 {
6270 PyThreadState* __tstate = wxPyBeginAllowThreads();
6271 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6272 wxPyEndAllowThreads(__tstate);
6273 if (PyErr_Occurred()) SWIG_fail;
6274 }
6275 resultobj = SWIG_Py_Void();
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj = 0;
6284 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6285 wxFont *arg2 = 0 ;
6286 void *argp1 = 0 ;
6287 int res1 = 0 ;
6288 void *argp2 = 0 ;
6289 int res2 = 0 ;
6290 PyObject * obj0 = 0 ;
6291 PyObject * obj1 = 0 ;
6292 char * kwnames[] = {
6293 (char *) "self",(char *) "font", NULL
6294 };
6295
6296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6298 if (!SWIG_IsOK(res1)) {
6299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6300 }
6301 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6302 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6303 if (!SWIG_IsOK(res2)) {
6304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6305 }
6306 if (!argp2) {
6307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6308 }
6309 arg2 = reinterpret_cast< wxFont * >(argp2);
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 (arg1)->SetFont((wxFont const &)*arg2);
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 resultobj = SWIG_Py_Void();
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj = 0;
6325 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6326 int arg2 ;
6327 int arg3 ;
6328 void *argp1 = 0 ;
6329 int res1 = 0 ;
6330 int val2 ;
6331 int ecode2 = 0 ;
6332 int val3 ;
6333 int ecode3 = 0 ;
6334 PyObject * obj0 = 0 ;
6335 PyObject * obj1 = 0 ;
6336 PyObject * obj2 = 0 ;
6337 char * kwnames[] = {
6338 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6339 };
6340
6341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6343 if (!SWIG_IsOK(res1)) {
6344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6345 }
6346 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6347 ecode2 = SWIG_AsVal_int(obj1, &val2);
6348 if (!SWIG_IsOK(ecode2)) {
6349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6350 }
6351 arg2 = static_cast< int >(val2);
6352 ecode3 = SWIG_AsVal_int(obj2, &val3);
6353 if (!SWIG_IsOK(ecode3)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6355 }
6356 arg3 = static_cast< int >(val3);
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 (arg1)->SetAlignment(arg2,arg3);
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 resultobj = SWIG_Py_Void();
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6371 PyObject *resultobj = 0;
6372 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6373 int arg2 ;
6374 int arg3 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 int val3 ;
6380 int ecode3 = 0 ;
6381 PyObject * obj0 = 0 ;
6382 PyObject * obj1 = 0 ;
6383 PyObject * obj2 = 0 ;
6384 char * kwnames[] = {
6385 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6386 };
6387
6388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6390 if (!SWIG_IsOK(res1)) {
6391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6392 }
6393 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6394 ecode2 = SWIG_AsVal_int(obj1, &val2);
6395 if (!SWIG_IsOK(ecode2)) {
6396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6397 }
6398 arg2 = static_cast< int >(val2);
6399 ecode3 = SWIG_AsVal_int(obj2, &val3);
6400 if (!SWIG_IsOK(ecode3)) {
6401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6402 }
6403 arg3 = static_cast< int >(val3);
6404 {
6405 PyThreadState* __tstate = wxPyBeginAllowThreads();
6406 (arg1)->SetSize(arg2,arg3);
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_Py_Void();
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6420 bool arg2 = (bool) true ;
6421 void *argp1 = 0 ;
6422 int res1 = 0 ;
6423 bool val2 ;
6424 int ecode2 = 0 ;
6425 PyObject * obj0 = 0 ;
6426 PyObject * obj1 = 0 ;
6427 char * kwnames[] = {
6428 (char *) "self",(char *) "allow", NULL
6429 };
6430
6431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6433 if (!SWIG_IsOK(res1)) {
6434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6435 }
6436 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6437 if (obj1) {
6438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6439 if (!SWIG_IsOK(ecode2)) {
6440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6441 }
6442 arg2 = static_cast< bool >(val2);
6443 }
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 (arg1)->SetOverflow(arg2);
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_Py_Void();
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj = 0;
6459 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6460 bool arg2 = (bool) true ;
6461 void *argp1 = 0 ;
6462 int res1 = 0 ;
6463 bool val2 ;
6464 int ecode2 = 0 ;
6465 PyObject * obj0 = 0 ;
6466 PyObject * obj1 = 0 ;
6467 char * kwnames[] = {
6468 (char *) "self",(char *) "isReadOnly", NULL
6469 };
6470
6471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6473 if (!SWIG_IsOK(res1)) {
6474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6475 }
6476 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6477 if (obj1) {
6478 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6479 if (!SWIG_IsOK(ecode2)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6481 }
6482 arg2 = static_cast< bool >(val2);
6483 }
6484 {
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 (arg1)->SetReadOnly(arg2);
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = SWIG_Py_Void();
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj = 0;
6499 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6500 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6501 void *argp1 = 0 ;
6502 int res1 = 0 ;
6503 void *argp2 = 0 ;
6504 int res2 = 0 ;
6505 PyObject * obj0 = 0 ;
6506 PyObject * obj1 = 0 ;
6507 char * kwnames[] = {
6508 (char *) "self",(char *) "renderer", NULL
6509 };
6510
6511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6513 if (!SWIG_IsOK(res1)) {
6514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6515 }
6516 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6518 if (!SWIG_IsOK(res2)) {
6519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6520 }
6521 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6522 {
6523 PyThreadState* __tstate = wxPyBeginAllowThreads();
6524 (arg1)->SetRenderer(arg2);
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_Py_Void();
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6538 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6539 void *argp1 = 0 ;
6540 int res1 = 0 ;
6541 void *argp2 = 0 ;
6542 int res2 = 0 ;
6543 PyObject * obj0 = 0 ;
6544 PyObject * obj1 = 0 ;
6545 char * kwnames[] = {
6546 (char *) "self",(char *) "editor", NULL
6547 };
6548
6549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6551 if (!SWIG_IsOK(res1)) {
6552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6553 }
6554 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6556 if (!SWIG_IsOK(res2)) {
6557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6558 }
6559 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 (arg1)->SetEditor(arg2);
6563 wxPyEndAllowThreads(__tstate);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_Py_Void();
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6574 PyObject *resultobj = 0;
6575 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6576 wxGridCellAttr::wxAttrKind arg2 ;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 int val2 ;
6580 int ecode2 = 0 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 char * kwnames[] = {
6584 (char *) "self",(char *) "kind", NULL
6585 };
6586
6587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6591 }
6592 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6593 ecode2 = SWIG_AsVal_int(obj1, &val2);
6594 if (!SWIG_IsOK(ecode2)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6596 }
6597 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6598 {
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 (arg1)->SetKind(arg2);
6601 wxPyEndAllowThreads(__tstate);
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 resultobj = SWIG_Py_Void();
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6612 PyObject *resultobj = 0;
6613 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6614 bool result;
6615 void *argp1 = 0 ;
6616 int res1 = 0 ;
6617 PyObject *swig_obj[1] ;
6618
6619 if (!args) SWIG_fail;
6620 swig_obj[0] = args;
6621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6622 if (!SWIG_IsOK(res1)) {
6623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6624 }
6625 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6626 {
6627 PyThreadState* __tstate = wxPyBeginAllowThreads();
6628 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6629 wxPyEndAllowThreads(__tstate);
6630 if (PyErr_Occurred()) SWIG_fail;
6631 }
6632 {
6633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6634 }
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6642 PyObject *resultobj = 0;
6643 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6644 bool result;
6645 void *argp1 = 0 ;
6646 int res1 = 0 ;
6647 PyObject *swig_obj[1] ;
6648
6649 if (!args) SWIG_fail;
6650 swig_obj[0] = args;
6651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6652 if (!SWIG_IsOK(res1)) {
6653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6654 }
6655 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 {
6663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6664 }
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6672 PyObject *resultobj = 0;
6673 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6674 bool result;
6675 void *argp1 = 0 ;
6676 int res1 = 0 ;
6677 PyObject *swig_obj[1] ;
6678
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6686 {
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6704 bool result;
6705 void *argp1 = 0 ;
6706 int res1 = 0 ;
6707 PyObject *swig_obj[1] ;
6708
6709 if (!args) SWIG_fail;
6710 swig_obj[0] = args;
6711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6714 }
6715 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 {
6723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6724 }
6725 return resultobj;
6726 fail:
6727 return NULL;
6728 }
6729
6730
6731 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6732 PyObject *resultobj = 0;
6733 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6734 bool result;
6735 void *argp1 = 0 ;
6736 int res1 = 0 ;
6737 PyObject *swig_obj[1] ;
6738
6739 if (!args) SWIG_fail;
6740 swig_obj[0] = args;
6741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6744 }
6745 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6746 {
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 {
6753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6754 }
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6762 PyObject *resultobj = 0;
6763 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6764 bool result;
6765 void *argp1 = 0 ;
6766 int res1 = 0 ;
6767 PyObject *swig_obj[1] ;
6768
6769 if (!args) SWIG_fail;
6770 swig_obj[0] = args;
6771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6774 }
6775 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6794 bool result;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 PyObject *swig_obj[1] ;
6798
6799 if (!args) SWIG_fail;
6800 swig_obj[0] = args;
6801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6802 if (!SWIG_IsOK(res1)) {
6803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6804 }
6805 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6806 {
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 {
6813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6814 }
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6824 bool result;
6825 void *argp1 = 0 ;
6826 int res1 = 0 ;
6827 PyObject *swig_obj[1] ;
6828
6829 if (!args) SWIG_fail;
6830 swig_obj[0] = args;
6831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6832 if (!SWIG_IsOK(res1)) {
6833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6834 }
6835 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6836 {
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6852 PyObject *resultobj = 0;
6853 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6854 wxColour result;
6855 void *argp1 = 0 ;
6856 int res1 = 0 ;
6857 PyObject *swig_obj[1] ;
6858
6859 if (!args) SWIG_fail;
6860 swig_obj[0] = args;
6861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6862 if (!SWIG_IsOK(res1)) {
6863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6864 }
6865 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6866 {
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6880 PyObject *resultobj = 0;
6881 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6882 wxColour result;
6883 void *argp1 = 0 ;
6884 int res1 = 0 ;
6885 PyObject *swig_obj[1] ;
6886
6887 if (!args) SWIG_fail;
6888 swig_obj[0] = args;
6889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6890 if (!SWIG_IsOK(res1)) {
6891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6892 }
6893 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6894 {
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6908 PyObject *resultobj = 0;
6909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6910 wxFont result;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 PyObject *swig_obj[1] ;
6914
6915 if (!args) SWIG_fail;
6916 swig_obj[0] = args;
6917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6918 if (!SWIG_IsOK(res1)) {
6919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6920 }
6921 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = ((wxGridCellAttr const *)arg1)->GetFont();
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 PyObject *resultobj = 0;
6937 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6938 int *arg2 = (int *) 0 ;
6939 int *arg3 = (int *) 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 int temp2 ;
6943 int res2 = SWIG_TMPOBJ ;
6944 int temp3 ;
6945 int res3 = SWIG_TMPOBJ ;
6946 PyObject *swig_obj[1] ;
6947
6948 arg2 = &temp2;
6949 arg3 = &temp3;
6950 if (!args) SWIG_fail;
6951 swig_obj[0] = args;
6952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6953 if (!SWIG_IsOK(res1)) {
6954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6955 }
6956 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6957 {
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6960 wxPyEndAllowThreads(__tstate);
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_Py_Void();
6964 if (SWIG_IsTmpObj(res2)) {
6965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6966 } else {
6967 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6969 }
6970 if (SWIG_IsTmpObj(res3)) {
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6972 } else {
6973 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6975 }
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6983 PyObject *resultobj = 0;
6984 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6985 int *arg2 = (int *) 0 ;
6986 int *arg3 = (int *) 0 ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 int temp2 ;
6990 int res2 = SWIG_TMPOBJ ;
6991 int temp3 ;
6992 int res3 = SWIG_TMPOBJ ;
6993 PyObject *swig_obj[1] ;
6994
6995 arg2 = &temp2;
6996 arg3 = &temp3;
6997 if (!args) SWIG_fail;
6998 swig_obj[0] = args;
6999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7000 if (!SWIG_IsOK(res1)) {
7001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7002 }
7003 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7004 {
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7007 wxPyEndAllowThreads(__tstate);
7008 if (PyErr_Occurred()) SWIG_fail;
7009 }
7010 resultobj = SWIG_Py_Void();
7011 if (SWIG_IsTmpObj(res2)) {
7012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7013 } else {
7014 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7016 }
7017 if (SWIG_IsTmpObj(res3)) {
7018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7019 } else {
7020 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7022 }
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7030 PyObject *resultobj = 0;
7031 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7032 bool result;
7033 void *argp1 = 0 ;
7034 int res1 = 0 ;
7035 PyObject *swig_obj[1] ;
7036
7037 if (!args) SWIG_fail;
7038 swig_obj[0] = args;
7039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7040 if (!SWIG_IsOK(res1)) {
7041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7042 }
7043 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7047 wxPyEndAllowThreads(__tstate);
7048 if (PyErr_Occurred()) SWIG_fail;
7049 }
7050 {
7051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7052 }
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7060 PyObject *resultobj = 0;
7061 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7062 wxGrid *arg2 = (wxGrid *) 0 ;
7063 int arg3 ;
7064 int arg4 ;
7065 wxGridCellRenderer *result = 0 ;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 void *argp2 = 0 ;
7069 int res2 = 0 ;
7070 int val3 ;
7071 int ecode3 = 0 ;
7072 int val4 ;
7073 int ecode4 = 0 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 PyObject * obj2 = 0 ;
7077 PyObject * obj3 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7084 if (!SWIG_IsOK(res1)) {
7085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7086 }
7087 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7088 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7089 if (!SWIG_IsOK(res2)) {
7090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7091 }
7092 arg2 = reinterpret_cast< wxGrid * >(argp2);
7093 ecode3 = SWIG_AsVal_int(obj2, &val3);
7094 if (!SWIG_IsOK(ecode3)) {
7095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7096 }
7097 arg3 = static_cast< int >(val3);
7098 ecode4 = SWIG_AsVal_int(obj3, &val4);
7099 if (!SWIG_IsOK(ecode4)) {
7100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7101 }
7102 arg4 = static_cast< int >(val4);
7103 {
7104 PyThreadState* __tstate = wxPyBeginAllowThreads();
7105 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj = 0;
7120 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7121 wxGrid *arg2 = (wxGrid *) 0 ;
7122 int arg3 ;
7123 int arg4 ;
7124 wxGridCellEditor *result = 0 ;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 void *argp2 = 0 ;
7128 int res2 = 0 ;
7129 int val3 ;
7130 int ecode3 = 0 ;
7131 int val4 ;
7132 int ecode4 = 0 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 PyObject * obj2 = 0 ;
7136 PyObject * obj3 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7145 }
7146 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7148 if (!SWIG_IsOK(res2)) {
7149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7150 }
7151 arg2 = reinterpret_cast< wxGrid * >(argp2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 ecode4 = SWIG_AsVal_int(obj3, &val4);
7158 if (!SWIG_IsOK(ecode4)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7160 }
7161 arg4 = static_cast< int >(val4);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 {
7169 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7170 }
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7178 PyObject *resultobj = 0;
7179 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7180 bool result;
7181 void *argp1 = 0 ;
7182 int res1 = 0 ;
7183 PyObject *swig_obj[1] ;
7184
7185 if (!args) SWIG_fail;
7186 swig_obj[0] = args;
7187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7188 if (!SWIG_IsOK(res1)) {
7189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7190 }
7191 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 {
7199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7200 }
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7208 PyObject *resultobj = 0;
7209 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7210 wxGridCellAttr::wxAttrKind result;
7211 void *argp1 = 0 ;
7212 int res1 = 0 ;
7213 PyObject *swig_obj[1] ;
7214
7215 if (!args) SWIG_fail;
7216 swig_obj[0] = args;
7217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7220 }
7221 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 resultobj = SWIG_From_int(static_cast< int >(result));
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7238 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 void *argp2 = 0 ;
7242 int res2 = 0 ;
7243 PyObject * obj0 = 0 ;
7244 PyObject * obj1 = 0 ;
7245 char * kwnames[] = {
7246 (char *) "self",(char *) "defAttr", NULL
7247 };
7248
7249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7251 if (!SWIG_IsOK(res1)) {
7252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7253 }
7254 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7256 if (!SWIG_IsOK(res2)) {
7257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7258 }
7259 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 (arg1)->SetDefAttr(arg2);
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_Py_Void();
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7274 PyObject *obj;
7275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7276 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7277 return SWIG_Py_Void();
7278 }
7279
7280 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7281 return SWIG_Python_InitShadowInstance(args);
7282 }
7283
7284 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7285 PyObject *resultobj = 0;
7286 wxGridCellAttrProvider *result = 0 ;
7287
7288 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 {
7296 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7297 }
7298 return resultobj;
7299 fail:
7300 return NULL;
7301 }
7302
7303
7304 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7305 PyObject *resultobj = 0;
7306 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7307 PyObject *arg2 = (PyObject *) 0 ;
7308 void *argp1 = 0 ;
7309 int res1 = 0 ;
7310 PyObject * obj0 = 0 ;
7311 PyObject * obj1 = 0 ;
7312 char * kwnames[] = {
7313 (char *) "self",(char *) "_self", NULL
7314 };
7315
7316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7318 if (!SWIG_IsOK(res1)) {
7319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7320 }
7321 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7322 arg2 = obj1;
7323 {
7324 PyThreadState* __tstate = wxPyBeginAllowThreads();
7325 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 resultobj = SWIG_Py_Void();
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj = 0;
7338 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7339 int arg2 ;
7340 int arg3 ;
7341 wxGridCellAttr::wxAttrKind arg4 ;
7342 wxGridCellAttr *result = 0 ;
7343 void *argp1 = 0 ;
7344 int res1 = 0 ;
7345 int val2 ;
7346 int ecode2 = 0 ;
7347 int val3 ;
7348 int ecode3 = 0 ;
7349 int val4 ;
7350 int ecode4 = 0 ;
7351 PyObject * obj0 = 0 ;
7352 PyObject * obj1 = 0 ;
7353 PyObject * obj2 = 0 ;
7354 PyObject * obj3 = 0 ;
7355 char * kwnames[] = {
7356 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7357 };
7358
7359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7361 if (!SWIG_IsOK(res1)) {
7362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7363 }
7364 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7365 ecode2 = SWIG_AsVal_int(obj1, &val2);
7366 if (!SWIG_IsOK(ecode2)) {
7367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7368 }
7369 arg2 = static_cast< int >(val2);
7370 ecode3 = SWIG_AsVal_int(obj2, &val3);
7371 if (!SWIG_IsOK(ecode3)) {
7372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7373 }
7374 arg3 = static_cast< int >(val3);
7375 ecode4 = SWIG_AsVal_int(obj3, &val4);
7376 if (!SWIG_IsOK(ecode4)) {
7377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7378 }
7379 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 {
7387 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7388 }
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj = 0;
7397 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7398 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7399 int arg3 ;
7400 int arg4 ;
7401 void *argp1 = 0 ;
7402 int res1 = 0 ;
7403 void *argp2 = 0 ;
7404 int res2 = 0 ;
7405 int val3 ;
7406 int ecode3 = 0 ;
7407 int val4 ;
7408 int ecode4 = 0 ;
7409 PyObject * obj0 = 0 ;
7410 PyObject * obj1 = 0 ;
7411 PyObject * obj2 = 0 ;
7412 PyObject * obj3 = 0 ;
7413 char * kwnames[] = {
7414 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7415 };
7416
7417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7419 if (!SWIG_IsOK(res1)) {
7420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7421 }
7422 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7424 if (!SWIG_IsOK(res2)) {
7425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7426 }
7427 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7428 ecode3 = SWIG_AsVal_int(obj2, &val3);
7429 if (!SWIG_IsOK(ecode3)) {
7430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7431 }
7432 arg3 = static_cast< int >(val3);
7433 ecode4 = SWIG_AsVal_int(obj3, &val4);
7434 if (!SWIG_IsOK(ecode4)) {
7435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7436 }
7437 arg4 = static_cast< int >(val4);
7438 {
7439 PyThreadState* __tstate = wxPyBeginAllowThreads();
7440 (arg1)->SetAttr(arg2,arg3,arg4);
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 resultobj = SWIG_Py_Void();
7445 return resultobj;
7446 fail:
7447 return NULL;
7448 }
7449
7450
7451 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7452 PyObject *resultobj = 0;
7453 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7454 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7455 int arg3 ;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 void *argp2 = 0 ;
7459 int res2 = 0 ;
7460 int val3 ;
7461 int ecode3 = 0 ;
7462 PyObject * obj0 = 0 ;
7463 PyObject * obj1 = 0 ;
7464 PyObject * obj2 = 0 ;
7465 char * kwnames[] = {
7466 (char *) "self",(char *) "attr",(char *) "row", NULL
7467 };
7468
7469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7471 if (!SWIG_IsOK(res1)) {
7472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7473 }
7474 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7476 if (!SWIG_IsOK(res2)) {
7477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7478 }
7479 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7480 ecode3 = SWIG_AsVal_int(obj2, &val3);
7481 if (!SWIG_IsOK(ecode3)) {
7482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7483 }
7484 arg3 = static_cast< int >(val3);
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 (arg1)->SetRowAttr(arg2,arg3);
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 resultobj = SWIG_Py_Void();
7492 return resultobj;
7493 fail:
7494 return NULL;
7495 }
7496
7497
7498 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7499 PyObject *resultobj = 0;
7500 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7501 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7502 int arg3 ;
7503 void *argp1 = 0 ;
7504 int res1 = 0 ;
7505 void *argp2 = 0 ;
7506 int res2 = 0 ;
7507 int val3 ;
7508 int ecode3 = 0 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 PyObject * obj2 = 0 ;
7512 char * kwnames[] = {
7513 (char *) "self",(char *) "attr",(char *) "col", NULL
7514 };
7515
7516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7518 if (!SWIG_IsOK(res1)) {
7519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7520 }
7521 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7522 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7523 if (!SWIG_IsOK(res2)) {
7524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7525 }
7526 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7527 ecode3 = SWIG_AsVal_int(obj2, &val3);
7528 if (!SWIG_IsOK(ecode3)) {
7529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7530 }
7531 arg3 = static_cast< int >(val3);
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 (arg1)->SetColAttr(arg2,arg3);
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 resultobj = SWIG_Py_Void();
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj = 0;
7547 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7548 size_t arg2 ;
7549 int arg3 ;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 size_t val2 ;
7553 int ecode2 = 0 ;
7554 int val3 ;
7555 int ecode3 = 0 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 PyObject * obj2 = 0 ;
7559 char * kwnames[] = {
7560 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7561 };
7562
7563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7567 }
7568 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7569 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7570 if (!SWIG_IsOK(ecode2)) {
7571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7572 }
7573 arg2 = static_cast< size_t >(val2);
7574 ecode3 = SWIG_AsVal_int(obj2, &val3);
7575 if (!SWIG_IsOK(ecode3)) {
7576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7577 }
7578 arg3 = static_cast< int >(val3);
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->UpdateAttrRows(arg2,arg3);
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_Py_Void();
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7595 size_t arg2 ;
7596 int arg3 ;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 size_t val2 ;
7600 int ecode2 = 0 ;
7601 int val3 ;
7602 int ecode3 = 0 ;
7603 PyObject * obj0 = 0 ;
7604 PyObject * obj1 = 0 ;
7605 PyObject * obj2 = 0 ;
7606 char * kwnames[] = {
7607 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7608 };
7609
7610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7612 if (!SWIG_IsOK(res1)) {
7613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7614 }
7615 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7616 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7617 if (!SWIG_IsOK(ecode2)) {
7618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7619 }
7620 arg2 = static_cast< size_t >(val2);
7621 ecode3 = SWIG_AsVal_int(obj2, &val3);
7622 if (!SWIG_IsOK(ecode3)) {
7623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7624 }
7625 arg3 = static_cast< int >(val3);
7626 {
7627 PyThreadState* __tstate = wxPyBeginAllowThreads();
7628 (arg1)->UpdateAttrCols(arg2,arg3);
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 resultobj = SWIG_Py_Void();
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7640 PyObject *obj;
7641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7642 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7643 return SWIG_Py_Void();
7644 }
7645
7646 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 return SWIG_Python_InitShadowInstance(args);
7648 }
7649
7650 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7651 PyObject *resultobj = 0;
7652 wxPyGridCellAttrProvider *result = 0 ;
7653
7654 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj = 0;
7670 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7671 PyObject *arg2 = (PyObject *) 0 ;
7672 PyObject *arg3 = (PyObject *) 0 ;
7673 void *argp1 = 0 ;
7674 int res1 = 0 ;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 PyObject * obj2 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "self",(char *) "_class", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7686 }
7687 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7688 arg2 = obj1;
7689 arg3 = obj2;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 (arg1)->_setCallbackInfo(arg2,arg3);
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 resultobj = SWIG_Py_Void();
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj = 0;
7705 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7706 int arg2 ;
7707 int arg3 ;
7708 wxGridCellAttr::wxAttrKind arg4 ;
7709 wxGridCellAttr *result = 0 ;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 int val2 ;
7713 int ecode2 = 0 ;
7714 int val3 ;
7715 int ecode3 = 0 ;
7716 int val4 ;
7717 int ecode4 = 0 ;
7718 PyObject * obj0 = 0 ;
7719 PyObject * obj1 = 0 ;
7720 PyObject * obj2 = 0 ;
7721 PyObject * obj3 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7730 }
7731 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7732 ecode2 = SWIG_AsVal_int(obj1, &val2);
7733 if (!SWIG_IsOK(ecode2)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7735 }
7736 arg2 = static_cast< int >(val2);
7737 ecode3 = SWIG_AsVal_int(obj2, &val3);
7738 if (!SWIG_IsOK(ecode3)) {
7739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7740 }
7741 arg3 = static_cast< int >(val3);
7742 ecode4 = SWIG_AsVal_int(obj3, &val4);
7743 if (!SWIG_IsOK(ecode4)) {
7744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7745 }
7746 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7747 {
7748 PyThreadState* __tstate = wxPyBeginAllowThreads();
7749 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj = 0;
7764 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7765 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7766 int arg3 ;
7767 int arg4 ;
7768 void *argp1 = 0 ;
7769 int res1 = 0 ;
7770 void *argp2 = 0 ;
7771 int res2 = 0 ;
7772 int val3 ;
7773 int ecode3 = 0 ;
7774 int val4 ;
7775 int ecode4 = 0 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 PyObject * obj2 = 0 ;
7779 PyObject * obj3 = 0 ;
7780 char * kwnames[] = {
7781 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7782 };
7783
7784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7786 if (!SWIG_IsOK(res1)) {
7787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7788 }
7789 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7791 if (!SWIG_IsOK(res2)) {
7792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7793 }
7794 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7795 ecode3 = SWIG_AsVal_int(obj2, &val3);
7796 if (!SWIG_IsOK(ecode3)) {
7797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7798 }
7799 arg3 = static_cast< int >(val3);
7800 ecode4 = SWIG_AsVal_int(obj3, &val4);
7801 if (!SWIG_IsOK(ecode4)) {
7802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7803 }
7804 arg4 = static_cast< int >(val4);
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 (arg1)->SetAttr(arg2,arg3,arg4);
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_Py_Void();
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj = 0;
7820 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7821 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7822 int arg3 ;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 void *argp2 = 0 ;
7826 int res2 = 0 ;
7827 int val3 ;
7828 int ecode3 = 0 ;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 PyObject * obj2 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "attr",(char *) "row", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7840 }
7841 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7842 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7843 if (!SWIG_IsOK(res2)) {
7844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7845 }
7846 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7847 ecode3 = SWIG_AsVal_int(obj2, &val3);
7848 if (!SWIG_IsOK(ecode3)) {
7849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7850 }
7851 arg3 = static_cast< int >(val3);
7852 {
7853 PyThreadState* __tstate = wxPyBeginAllowThreads();
7854 (arg1)->SetRowAttr(arg2,arg3);
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 resultobj = SWIG_Py_Void();
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj = 0;
7867 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7868 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7869 int arg3 ;
7870 void *argp1 = 0 ;
7871 int res1 = 0 ;
7872 void *argp2 = 0 ;
7873 int res2 = 0 ;
7874 int val3 ;
7875 int ecode3 = 0 ;
7876 PyObject * obj0 = 0 ;
7877 PyObject * obj1 = 0 ;
7878 PyObject * obj2 = 0 ;
7879 char * kwnames[] = {
7880 (char *) "self",(char *) "attr",(char *) "col", NULL
7881 };
7882
7883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7885 if (!SWIG_IsOK(res1)) {
7886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7887 }
7888 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7890 if (!SWIG_IsOK(res2)) {
7891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7892 }
7893 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7894 ecode3 = SWIG_AsVal_int(obj2, &val3);
7895 if (!SWIG_IsOK(ecode3)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7897 }
7898 arg3 = static_cast< int >(val3);
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 (arg1)->SetColAttr(arg2,arg3);
7902 wxPyEndAllowThreads(__tstate);
7903 if (PyErr_Occurred()) SWIG_fail;
7904 }
7905 resultobj = SWIG_Py_Void();
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 PyObject *obj;
7914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7915 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7916 return SWIG_Py_Void();
7917 }
7918
7919 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 return SWIG_Python_InitShadowInstance(args);
7921 }
7922
7923 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7924 PyObject *resultobj = 0;
7925 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7926 void *argp1 = 0 ;
7927 int res1 = 0 ;
7928 PyObject *swig_obj[1] ;
7929
7930 if (!args) SWIG_fail;
7931 swig_obj[0] = args;
7932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7935 }
7936 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7937 {
7938 PyThreadState* __tstate = wxPyBeginAllowThreads();
7939 delete arg1;
7940
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 resultobj = SWIG_Py_Void();
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj = 0;
7953 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7954 PyObject *arg2 = (PyObject *) 0 ;
7955 void *argp1 = 0 ;
7956 int res1 = 0 ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 char * kwnames[] = {
7960 (char *) "self",(char *) "_self", NULL
7961 };
7962
7963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7967 }
7968 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7969 arg2 = obj1;
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 wxGridTableBase__setOORInfo(arg1,arg2);
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 resultobj = SWIG_Py_Void();
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7984 PyObject *resultobj = 0;
7985 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7986 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 void *argp2 = 0 ;
7990 int res2 = 0 ;
7991 PyObject * obj0 = 0 ;
7992 PyObject * obj1 = 0 ;
7993 char * kwnames[] = {
7994 (char *) "self",(char *) "attrProvider", NULL
7995 };
7996
7997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7999 if (!SWIG_IsOK(res1)) {
8000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8001 }
8002 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8004 if (!SWIG_IsOK(res2)) {
8005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8006 }
8007 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 (arg1)->SetAttrProvider(arg2);
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = SWIG_Py_Void();
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8024 wxGridCellAttrProvider *result = 0 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 PyObject *swig_obj[1] ;
8028
8029 if (!args) SWIG_fail;
8030 swig_obj[0] = args;
8031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8032 if (!SWIG_IsOK(res1)) {
8033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8034 }
8035 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 {
8043 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8044 }
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj = 0;
8053 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8054 wxGrid *arg2 = (wxGrid *) 0 ;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 void *argp2 = 0 ;
8058 int res2 = 0 ;
8059 PyObject * obj0 = 0 ;
8060 PyObject * obj1 = 0 ;
8061 char * kwnames[] = {
8062 (char *) "self",(char *) "grid", NULL
8063 };
8064
8065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8067 if (!SWIG_IsOK(res1)) {
8068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8069 }
8070 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8072 if (!SWIG_IsOK(res2)) {
8073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8074 }
8075 arg2 = reinterpret_cast< wxGrid * >(argp2);
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 (arg1)->SetView(arg2);
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8092 wxGrid *result = 0 ;
8093 void *argp1 = 0 ;
8094 int res1 = 0 ;
8095 PyObject *swig_obj[1] ;
8096
8097 if (!args) SWIG_fail;
8098 swig_obj[0] = args;
8099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8100 if (!SWIG_IsOK(res1)) {
8101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8102 }
8103 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8107 wxPyEndAllowThreads(__tstate);
8108 if (PyErr_Occurred()) SWIG_fail;
8109 }
8110 {
8111 resultobj = wxPyMake_wxObject(result, (bool)0);
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8122 int result;
8123 void *argp1 = 0 ;
8124 int res1 = 0 ;
8125 PyObject *swig_obj[1] ;
8126
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8132 }
8133 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = (int)(arg1)->GetNumberRows();
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_From_int(static_cast< int >(result));
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8148 PyObject *resultobj = 0;
8149 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8150 int result;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 PyObject *swig_obj[1] ;
8154
8155 if (!args) SWIG_fail;
8156 swig_obj[0] = args;
8157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8158 if (!SWIG_IsOK(res1)) {
8159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8160 }
8161 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (int)(arg1)->GetNumberCols();
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 resultobj = SWIG_From_int(static_cast< int >(result));
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj = 0;
8177 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8178 int arg2 ;
8179 int arg3 ;
8180 bool result;
8181 void *argp1 = 0 ;
8182 int res1 = 0 ;
8183 int val2 ;
8184 int ecode2 = 0 ;
8185 int val3 ;
8186 int ecode3 = 0 ;
8187 PyObject * obj0 = 0 ;
8188 PyObject * obj1 = 0 ;
8189 PyObject * obj2 = 0 ;
8190 char * kwnames[] = {
8191 (char *) "self",(char *) "row",(char *) "col", NULL
8192 };
8193
8194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8196 if (!SWIG_IsOK(res1)) {
8197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8198 }
8199 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8200 ecode2 = SWIG_AsVal_int(obj1, &val2);
8201 if (!SWIG_IsOK(ecode2)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8203 }
8204 arg2 = static_cast< int >(val2);
8205 ecode3 = SWIG_AsVal_int(obj2, &val3);
8206 if (!SWIG_IsOK(ecode3)) {
8207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8208 }
8209 arg3 = static_cast< int >(val3);
8210 {
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 {
8217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8218 }
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj = 0;
8227 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8228 int arg2 ;
8229 int arg3 ;
8230 wxString result;
8231 void *argp1 = 0 ;
8232 int res1 = 0 ;
8233 int val2 ;
8234 int ecode2 = 0 ;
8235 int val3 ;
8236 int ecode3 = 0 ;
8237 PyObject * obj0 = 0 ;
8238 PyObject * obj1 = 0 ;
8239 PyObject * obj2 = 0 ;
8240 char * kwnames[] = {
8241 (char *) "self",(char *) "row",(char *) "col", NULL
8242 };
8243
8244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8248 }
8249 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8250 ecode2 = SWIG_AsVal_int(obj1, &val2);
8251 if (!SWIG_IsOK(ecode2)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8253 }
8254 arg2 = static_cast< int >(val2);
8255 ecode3 = SWIG_AsVal_int(obj2, &val3);
8256 if (!SWIG_IsOK(ecode3)) {
8257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8258 }
8259 arg3 = static_cast< int >(val3);
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 result = (arg1)->GetValue(arg2,arg3);
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 {
8267 #if wxUSE_UNICODE
8268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8269 #else
8270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8271 #endif
8272 }
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj = 0;
8281 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8282 int arg2 ;
8283 int arg3 ;
8284 wxString *arg4 = 0 ;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 int val2 ;
8288 int ecode2 = 0 ;
8289 int val3 ;
8290 int ecode3 = 0 ;
8291 bool temp4 = false ;
8292 PyObject * obj0 = 0 ;
8293 PyObject * obj1 = 0 ;
8294 PyObject * obj2 = 0 ;
8295 PyObject * obj3 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8302 if (!SWIG_IsOK(res1)) {
8303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8304 }
8305 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8306 ecode2 = SWIG_AsVal_int(obj1, &val2);
8307 if (!SWIG_IsOK(ecode2)) {
8308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8309 }
8310 arg2 = static_cast< int >(val2);
8311 ecode3 = SWIG_AsVal_int(obj2, &val3);
8312 if (!SWIG_IsOK(ecode3)) {
8313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8314 }
8315 arg3 = static_cast< int >(val3);
8316 {
8317 arg4 = wxString_in_helper(obj3);
8318 if (arg4 == NULL) SWIG_fail;
8319 temp4 = true;
8320 }
8321 {
8322 PyThreadState* __tstate = wxPyBeginAllowThreads();
8323 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8324 wxPyEndAllowThreads(__tstate);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 resultobj = SWIG_Py_Void();
8328 {
8329 if (temp4)
8330 delete arg4;
8331 }
8332 return resultobj;
8333 fail:
8334 {
8335 if (temp4)
8336 delete arg4;
8337 }
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj = 0;
8344 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8345 int arg2 ;
8346 int arg3 ;
8347 wxString result;
8348 void *argp1 = 0 ;
8349 int res1 = 0 ;
8350 int val2 ;
8351 int ecode2 = 0 ;
8352 int val3 ;
8353 int ecode3 = 0 ;
8354 PyObject * obj0 = 0 ;
8355 PyObject * obj1 = 0 ;
8356 PyObject * obj2 = 0 ;
8357 char * kwnames[] = {
8358 (char *) "self",(char *) "row",(char *) "col", NULL
8359 };
8360
8361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8363 if (!SWIG_IsOK(res1)) {
8364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8365 }
8366 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8367 ecode2 = SWIG_AsVal_int(obj1, &val2);
8368 if (!SWIG_IsOK(ecode2)) {
8369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8370 }
8371 arg2 = static_cast< int >(val2);
8372 ecode3 = SWIG_AsVal_int(obj2, &val3);
8373 if (!SWIG_IsOK(ecode3)) {
8374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8375 }
8376 arg3 = static_cast< int >(val3);
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 result = (arg1)->GetTypeName(arg2,arg3);
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 {
8384 #if wxUSE_UNICODE
8385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8386 #else
8387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8388 #endif
8389 }
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8397 PyObject *resultobj = 0;
8398 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8399 int arg2 ;
8400 int arg3 ;
8401 wxString *arg4 = 0 ;
8402 bool result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 int val2 ;
8406 int ecode2 = 0 ;
8407 int val3 ;
8408 int ecode3 = 0 ;
8409 bool temp4 = false ;
8410 PyObject * obj0 = 0 ;
8411 PyObject * obj1 = 0 ;
8412 PyObject * obj2 = 0 ;
8413 PyObject * obj3 = 0 ;
8414 char * kwnames[] = {
8415 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8416 };
8417
8418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8420 if (!SWIG_IsOK(res1)) {
8421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8422 }
8423 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8424 ecode2 = SWIG_AsVal_int(obj1, &val2);
8425 if (!SWIG_IsOK(ecode2)) {
8426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8427 }
8428 arg2 = static_cast< int >(val2);
8429 ecode3 = SWIG_AsVal_int(obj2, &val3);
8430 if (!SWIG_IsOK(ecode3)) {
8431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8432 }
8433 arg3 = static_cast< int >(val3);
8434 {
8435 arg4 = wxString_in_helper(obj3);
8436 if (arg4 == NULL) SWIG_fail;
8437 temp4 = true;
8438 }
8439 {
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8442 wxPyEndAllowThreads(__tstate);
8443 if (PyErr_Occurred()) SWIG_fail;
8444 }
8445 {
8446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8447 }
8448 {
8449 if (temp4)
8450 delete arg4;
8451 }
8452 return resultobj;
8453 fail:
8454 {
8455 if (temp4)
8456 delete arg4;
8457 }
8458 return NULL;
8459 }
8460
8461
8462 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8463 PyObject *resultobj = 0;
8464 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8465 int arg2 ;
8466 int arg3 ;
8467 wxString *arg4 = 0 ;
8468 bool result;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 int val2 ;
8472 int ecode2 = 0 ;
8473 int val3 ;
8474 int ecode3 = 0 ;
8475 bool temp4 = false ;
8476 PyObject * obj0 = 0 ;
8477 PyObject * obj1 = 0 ;
8478 PyObject * obj2 = 0 ;
8479 PyObject * obj3 = 0 ;
8480 char * kwnames[] = {
8481 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8482 };
8483
8484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8486 if (!SWIG_IsOK(res1)) {
8487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8488 }
8489 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8490 ecode2 = SWIG_AsVal_int(obj1, &val2);
8491 if (!SWIG_IsOK(ecode2)) {
8492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8493 }
8494 arg2 = static_cast< int >(val2);
8495 ecode3 = SWIG_AsVal_int(obj2, &val3);
8496 if (!SWIG_IsOK(ecode3)) {
8497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8498 }
8499 arg3 = static_cast< int >(val3);
8500 {
8501 arg4 = wxString_in_helper(obj3);
8502 if (arg4 == NULL) SWIG_fail;
8503 temp4 = true;
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8508 wxPyEndAllowThreads(__tstate);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 {
8512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8513 }
8514 {
8515 if (temp4)
8516 delete arg4;
8517 }
8518 return resultobj;
8519 fail:
8520 {
8521 if (temp4)
8522 delete arg4;
8523 }
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8529 PyObject *resultobj = 0;
8530 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8531 int arg2 ;
8532 int arg3 ;
8533 long result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 int val2 ;
8537 int ecode2 = 0 ;
8538 int val3 ;
8539 int ecode3 = 0 ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 PyObject * obj2 = 0 ;
8543 char * kwnames[] = {
8544 (char *) "self",(char *) "row",(char *) "col", NULL
8545 };
8546
8547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8549 if (!SWIG_IsOK(res1)) {
8550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8551 }
8552 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8553 ecode2 = SWIG_AsVal_int(obj1, &val2);
8554 if (!SWIG_IsOK(ecode2)) {
8555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8556 }
8557 arg2 = static_cast< int >(val2);
8558 ecode3 = SWIG_AsVal_int(obj2, &val3);
8559 if (!SWIG_IsOK(ecode3)) {
8560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8561 }
8562 arg3 = static_cast< int >(val3);
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 resultobj = SWIG_From_long(static_cast< long >(result));
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8577 PyObject *resultobj = 0;
8578 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8579 int arg2 ;
8580 int arg3 ;
8581 double result;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 int val2 ;
8585 int ecode2 = 0 ;
8586 int val3 ;
8587 int ecode3 = 0 ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 PyObject * obj2 = 0 ;
8591 char * kwnames[] = {
8592 (char *) "self",(char *) "row",(char *) "col", NULL
8593 };
8594
8595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8597 if (!SWIG_IsOK(res1)) {
8598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8599 }
8600 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8601 ecode2 = SWIG_AsVal_int(obj1, &val2);
8602 if (!SWIG_IsOK(ecode2)) {
8603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8604 }
8605 arg2 = static_cast< int >(val2);
8606 ecode3 = SWIG_AsVal_int(obj2, &val3);
8607 if (!SWIG_IsOK(ecode3)) {
8608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8609 }
8610 arg3 = static_cast< int >(val3);
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 resultobj = SWIG_From_double(static_cast< double >(result));
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj = 0;
8626 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8627 int arg2 ;
8628 int arg3 ;
8629 bool result;
8630 void *argp1 = 0 ;
8631 int res1 = 0 ;
8632 int val2 ;
8633 int ecode2 = 0 ;
8634 int val3 ;
8635 int ecode3 = 0 ;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 PyObject * obj2 = 0 ;
8639 char * kwnames[] = {
8640 (char *) "self",(char *) "row",(char *) "col", NULL
8641 };
8642
8643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8645 if (!SWIG_IsOK(res1)) {
8646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8647 }
8648 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8649 ecode2 = SWIG_AsVal_int(obj1, &val2);
8650 if (!SWIG_IsOK(ecode2)) {
8651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8652 }
8653 arg2 = static_cast< int >(val2);
8654 ecode3 = SWIG_AsVal_int(obj2, &val3);
8655 if (!SWIG_IsOK(ecode3)) {
8656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8657 }
8658 arg3 = static_cast< int >(val3);
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 {
8666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8667 }
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8675 PyObject *resultobj = 0;
8676 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8677 int arg2 ;
8678 int arg3 ;
8679 long arg4 ;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 int val2 ;
8683 int ecode2 = 0 ;
8684 int val3 ;
8685 int ecode3 = 0 ;
8686 long val4 ;
8687 int ecode4 = 0 ;
8688 PyObject * obj0 = 0 ;
8689 PyObject * obj1 = 0 ;
8690 PyObject * obj2 = 0 ;
8691 PyObject * obj3 = 0 ;
8692 char * kwnames[] = {
8693 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8694 };
8695
8696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8698 if (!SWIG_IsOK(res1)) {
8699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8700 }
8701 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8702 ecode2 = SWIG_AsVal_int(obj1, &val2);
8703 if (!SWIG_IsOK(ecode2)) {
8704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8705 }
8706 arg2 = static_cast< int >(val2);
8707 ecode3 = SWIG_AsVal_int(obj2, &val3);
8708 if (!SWIG_IsOK(ecode3)) {
8709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8710 }
8711 arg3 = static_cast< int >(val3);
8712 ecode4 = SWIG_AsVal_long(obj3, &val4);
8713 if (!SWIG_IsOK(ecode4)) {
8714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8715 }
8716 arg4 = static_cast< long >(val4);
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 resultobj = SWIG_Py_Void();
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj = 0;
8732 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8733 int arg2 ;
8734 int arg3 ;
8735 double arg4 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 int val2 ;
8739 int ecode2 = 0 ;
8740 int val3 ;
8741 int ecode3 = 0 ;
8742 double val4 ;
8743 int ecode4 = 0 ;
8744 PyObject * obj0 = 0 ;
8745 PyObject * obj1 = 0 ;
8746 PyObject * obj2 = 0 ;
8747 PyObject * obj3 = 0 ;
8748 char * kwnames[] = {
8749 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8750 };
8751
8752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8756 }
8757 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8758 ecode2 = SWIG_AsVal_int(obj1, &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8761 }
8762 arg2 = static_cast< int >(val2);
8763 ecode3 = SWIG_AsVal_int(obj2, &val3);
8764 if (!SWIG_IsOK(ecode3)) {
8765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8766 }
8767 arg3 = static_cast< int >(val3);
8768 ecode4 = SWIG_AsVal_double(obj3, &val4);
8769 if (!SWIG_IsOK(ecode4)) {
8770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8771 }
8772 arg4 = static_cast< double >(val4);
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8776 wxPyEndAllowThreads(__tstate);
8777 if (PyErr_Occurred()) SWIG_fail;
8778 }
8779 resultobj = SWIG_Py_Void();
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj = 0;
8788 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8789 int arg2 ;
8790 int arg3 ;
8791 bool arg4 ;
8792 void *argp1 = 0 ;
8793 int res1 = 0 ;
8794 int val2 ;
8795 int ecode2 = 0 ;
8796 int val3 ;
8797 int ecode3 = 0 ;
8798 bool val4 ;
8799 int ecode4 = 0 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 PyObject * obj2 = 0 ;
8803 PyObject * obj3 = 0 ;
8804 char * kwnames[] = {
8805 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8806 };
8807
8808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8812 }
8813 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8814 ecode2 = SWIG_AsVal_int(obj1, &val2);
8815 if (!SWIG_IsOK(ecode2)) {
8816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8817 }
8818 arg2 = static_cast< int >(val2);
8819 ecode3 = SWIG_AsVal_int(obj2, &val3);
8820 if (!SWIG_IsOK(ecode3)) {
8821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8822 }
8823 arg3 = static_cast< int >(val3);
8824 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8825 if (!SWIG_IsOK(ecode4)) {
8826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8827 }
8828 arg4 = static_cast< bool >(val4);
8829 {
8830 PyThreadState* __tstate = wxPyBeginAllowThreads();
8831 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 resultobj = SWIG_Py_Void();
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8843 PyObject *resultobj = 0;
8844 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8845 void *argp1 = 0 ;
8846 int res1 = 0 ;
8847 PyObject *swig_obj[1] ;
8848
8849 if (!args) SWIG_fail;
8850 swig_obj[0] = args;
8851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8854 }
8855 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 (arg1)->Clear();
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_Py_Void();
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj = 0;
8871 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8872 size_t arg2 = (size_t) 0 ;
8873 size_t arg3 = (size_t) 1 ;
8874 bool result;
8875 void *argp1 = 0 ;
8876 int res1 = 0 ;
8877 size_t val2 ;
8878 int ecode2 = 0 ;
8879 size_t val3 ;
8880 int ecode3 = 0 ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 PyObject * obj2 = 0 ;
8884 char * kwnames[] = {
8885 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8886 };
8887
8888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8890 if (!SWIG_IsOK(res1)) {
8891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8892 }
8893 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8894 if (obj1) {
8895 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8896 if (!SWIG_IsOK(ecode2)) {
8897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8898 }
8899 arg2 = static_cast< size_t >(val2);
8900 }
8901 if (obj2) {
8902 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8903 if (!SWIG_IsOK(ecode3)) {
8904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8905 }
8906 arg3 = static_cast< size_t >(val3);
8907 }
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 result = (bool)(arg1)->InsertRows(arg2,arg3);
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 {
8915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8916 }
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj = 0;
8925 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8926 size_t arg2 = (size_t) 1 ;
8927 bool result;
8928 void *argp1 = 0 ;
8929 int res1 = 0 ;
8930 size_t val2 ;
8931 int ecode2 = 0 ;
8932 PyObject * obj0 = 0 ;
8933 PyObject * obj1 = 0 ;
8934 char * kwnames[] = {
8935 (char *) "self",(char *) "numRows", NULL
8936 };
8937
8938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8942 }
8943 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8944 if (obj1) {
8945 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8946 if (!SWIG_IsOK(ecode2)) {
8947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8948 }
8949 arg2 = static_cast< size_t >(val2);
8950 }
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (bool)(arg1)->AppendRows(arg2);
8954 wxPyEndAllowThreads(__tstate);
8955 if (PyErr_Occurred()) SWIG_fail;
8956 }
8957 {
8958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8959 }
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj = 0;
8968 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8969 size_t arg2 = (size_t) 0 ;
8970 size_t arg3 = (size_t) 1 ;
8971 bool result;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 size_t val2 ;
8975 int ecode2 = 0 ;
8976 size_t val3 ;
8977 int ecode3 = 0 ;
8978 PyObject * obj0 = 0 ;
8979 PyObject * obj1 = 0 ;
8980 PyObject * obj2 = 0 ;
8981 char * kwnames[] = {
8982 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8983 };
8984
8985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8987 if (!SWIG_IsOK(res1)) {
8988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8989 }
8990 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8991 if (obj1) {
8992 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8993 if (!SWIG_IsOK(ecode2)) {
8994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8995 }
8996 arg2 = static_cast< size_t >(val2);
8997 }
8998 if (obj2) {
8999 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9000 if (!SWIG_IsOK(ecode3)) {
9001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
9002 }
9003 arg3 = static_cast< size_t >(val3);
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 {
9012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9013 }
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj = 0;
9022 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9023 size_t arg2 = (size_t) 0 ;
9024 size_t arg3 = (size_t) 1 ;
9025 bool result;
9026 void *argp1 = 0 ;
9027 int res1 = 0 ;
9028 size_t val2 ;
9029 int ecode2 = 0 ;
9030 size_t val3 ;
9031 int ecode3 = 0 ;
9032 PyObject * obj0 = 0 ;
9033 PyObject * obj1 = 0 ;
9034 PyObject * obj2 = 0 ;
9035 char * kwnames[] = {
9036 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9037 };
9038
9039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9041 if (!SWIG_IsOK(res1)) {
9042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9043 }
9044 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9045 if (obj1) {
9046 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9047 if (!SWIG_IsOK(ecode2)) {
9048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9049 }
9050 arg2 = static_cast< size_t >(val2);
9051 }
9052 if (obj2) {
9053 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9054 if (!SWIG_IsOK(ecode3)) {
9055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9056 }
9057 arg3 = static_cast< size_t >(val3);
9058 }
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 result = (bool)(arg1)->InsertCols(arg2,arg3);
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 {
9066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9067 }
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9075 PyObject *resultobj = 0;
9076 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9077 size_t arg2 = (size_t) 1 ;
9078 bool result;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 size_t val2 ;
9082 int ecode2 = 0 ;
9083 PyObject * obj0 = 0 ;
9084 PyObject * obj1 = 0 ;
9085 char * kwnames[] = {
9086 (char *) "self",(char *) "numCols", NULL
9087 };
9088
9089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9091 if (!SWIG_IsOK(res1)) {
9092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9093 }
9094 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9095 if (obj1) {
9096 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9097 if (!SWIG_IsOK(ecode2)) {
9098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9099 }
9100 arg2 = static_cast< size_t >(val2);
9101 }
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 result = (bool)(arg1)->AppendCols(arg2);
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 {
9109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9110 }
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9120 size_t arg2 = (size_t) 0 ;
9121 size_t arg3 = (size_t) 1 ;
9122 bool result;
9123 void *argp1 = 0 ;
9124 int res1 = 0 ;
9125 size_t val2 ;
9126 int ecode2 = 0 ;
9127 size_t val3 ;
9128 int ecode3 = 0 ;
9129 PyObject * obj0 = 0 ;
9130 PyObject * obj1 = 0 ;
9131 PyObject * obj2 = 0 ;
9132 char * kwnames[] = {
9133 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9134 };
9135
9136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9138 if (!SWIG_IsOK(res1)) {
9139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9140 }
9141 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9142 if (obj1) {
9143 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9144 if (!SWIG_IsOK(ecode2)) {
9145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9146 }
9147 arg2 = static_cast< size_t >(val2);
9148 }
9149 if (obj2) {
9150 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9151 if (!SWIG_IsOK(ecode3)) {
9152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9153 }
9154 arg3 = static_cast< size_t >(val3);
9155 }
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 {
9163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9164 }
9165 return resultobj;
9166 fail:
9167 return NULL;
9168 }
9169
9170
9171 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9172 PyObject *resultobj = 0;
9173 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9174 int arg2 ;
9175 wxString result;
9176 void *argp1 = 0 ;
9177 int res1 = 0 ;
9178 int val2 ;
9179 int ecode2 = 0 ;
9180 PyObject * obj0 = 0 ;
9181 PyObject * obj1 = 0 ;
9182 char * kwnames[] = {
9183 (char *) "self",(char *) "row", NULL
9184 };
9185
9186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9188 if (!SWIG_IsOK(res1)) {
9189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9190 }
9191 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9192 ecode2 = SWIG_AsVal_int(obj1, &val2);
9193 if (!SWIG_IsOK(ecode2)) {
9194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9195 }
9196 arg2 = static_cast< int >(val2);
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 result = (arg1)->GetRowLabelValue(arg2);
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 {
9204 #if wxUSE_UNICODE
9205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9206 #else
9207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9208 #endif
9209 }
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9217 PyObject *resultobj = 0;
9218 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9219 int arg2 ;
9220 wxString result;
9221 void *argp1 = 0 ;
9222 int res1 = 0 ;
9223 int val2 ;
9224 int ecode2 = 0 ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 char * kwnames[] = {
9228 (char *) "self",(char *) "col", NULL
9229 };
9230
9231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9235 }
9236 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9237 ecode2 = SWIG_AsVal_int(obj1, &val2);
9238 if (!SWIG_IsOK(ecode2)) {
9239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9240 }
9241 arg2 = static_cast< int >(val2);
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 result = (arg1)->GetColLabelValue(arg2);
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 {
9249 #if wxUSE_UNICODE
9250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9251 #else
9252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9253 #endif
9254 }
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj = 0;
9263 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9264 int arg2 ;
9265 wxString *arg3 = 0 ;
9266 void *argp1 = 0 ;
9267 int res1 = 0 ;
9268 int val2 ;
9269 int ecode2 = 0 ;
9270 bool temp3 = false ;
9271 PyObject * obj0 = 0 ;
9272 PyObject * obj1 = 0 ;
9273 PyObject * obj2 = 0 ;
9274 char * kwnames[] = {
9275 (char *) "self",(char *) "row",(char *) "value", NULL
9276 };
9277
9278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9280 if (!SWIG_IsOK(res1)) {
9281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9282 }
9283 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9284 ecode2 = SWIG_AsVal_int(obj1, &val2);
9285 if (!SWIG_IsOK(ecode2)) {
9286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9287 }
9288 arg2 = static_cast< int >(val2);
9289 {
9290 arg3 = wxString_in_helper(obj2);
9291 if (arg3 == NULL) SWIG_fail;
9292 temp3 = true;
9293 }
9294 {
9295 PyThreadState* __tstate = wxPyBeginAllowThreads();
9296 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 resultobj = SWIG_Py_Void();
9301 {
9302 if (temp3)
9303 delete arg3;
9304 }
9305 return resultobj;
9306 fail:
9307 {
9308 if (temp3)
9309 delete arg3;
9310 }
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = 0;
9317 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9318 int arg2 ;
9319 wxString *arg3 = 0 ;
9320 void *argp1 = 0 ;
9321 int res1 = 0 ;
9322 int val2 ;
9323 int ecode2 = 0 ;
9324 bool temp3 = false ;
9325 PyObject * obj0 = 0 ;
9326 PyObject * obj1 = 0 ;
9327 PyObject * obj2 = 0 ;
9328 char * kwnames[] = {
9329 (char *) "self",(char *) "col",(char *) "value", NULL
9330 };
9331
9332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9334 if (!SWIG_IsOK(res1)) {
9335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9336 }
9337 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9338 ecode2 = SWIG_AsVal_int(obj1, &val2);
9339 if (!SWIG_IsOK(ecode2)) {
9340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9341 }
9342 arg2 = static_cast< int >(val2);
9343 {
9344 arg3 = wxString_in_helper(obj2);
9345 if (arg3 == NULL) SWIG_fail;
9346 temp3 = true;
9347 }
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 resultobj = SWIG_Py_Void();
9355 {
9356 if (temp3)
9357 delete arg3;
9358 }
9359 return resultobj;
9360 fail:
9361 {
9362 if (temp3)
9363 delete arg3;
9364 }
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9372 bool result;
9373 void *argp1 = 0 ;
9374 int res1 = 0 ;
9375 PyObject *swig_obj[1] ;
9376
9377 if (!args) SWIG_fail;
9378 swig_obj[0] = args;
9379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9382 }
9383 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 result = (bool)(arg1)->CanHaveAttributes();
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 {
9391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9392 }
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj = 0;
9401 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9402 int arg2 ;
9403 int arg3 ;
9404 wxGridCellAttr::wxAttrKind arg4 ;
9405 wxGridCellAttr *result = 0 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 int val2 ;
9409 int ecode2 = 0 ;
9410 int val3 ;
9411 int ecode3 = 0 ;
9412 int val4 ;
9413 int ecode4 = 0 ;
9414 PyObject * obj0 = 0 ;
9415 PyObject * obj1 = 0 ;
9416 PyObject * obj2 = 0 ;
9417 PyObject * obj3 = 0 ;
9418 char * kwnames[] = {
9419 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9420 };
9421
9422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9424 if (!SWIG_IsOK(res1)) {
9425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9426 }
9427 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9428 ecode2 = SWIG_AsVal_int(obj1, &val2);
9429 if (!SWIG_IsOK(ecode2)) {
9430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9431 }
9432 arg2 = static_cast< int >(val2);
9433 ecode3 = SWIG_AsVal_int(obj2, &val3);
9434 if (!SWIG_IsOK(ecode3)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9436 }
9437 arg3 = static_cast< int >(val3);
9438 ecode4 = SWIG_AsVal_int(obj3, &val4);
9439 if (!SWIG_IsOK(ecode4)) {
9440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9441 }
9442 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 {
9450 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9451 }
9452 return resultobj;
9453 fail:
9454 return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9459 PyObject *resultobj = 0;
9460 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9461 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9462 int arg3 ;
9463 int arg4 ;
9464 void *argp1 = 0 ;
9465 int res1 = 0 ;
9466 void *argp2 = 0 ;
9467 int res2 = 0 ;
9468 int val3 ;
9469 int ecode3 = 0 ;
9470 int val4 ;
9471 int ecode4 = 0 ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9474 PyObject * obj2 = 0 ;
9475 PyObject * obj3 = 0 ;
9476 char * kwnames[] = {
9477 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9478 };
9479
9480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9482 if (!SWIG_IsOK(res1)) {
9483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9484 }
9485 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9487 if (!SWIG_IsOK(res2)) {
9488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9489 }
9490 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9491 ecode3 = SWIG_AsVal_int(obj2, &val3);
9492 if (!SWIG_IsOK(ecode3)) {
9493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9494 }
9495 arg3 = static_cast< int >(val3);
9496 ecode4 = SWIG_AsVal_int(obj3, &val4);
9497 if (!SWIG_IsOK(ecode4)) {
9498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9499 }
9500 arg4 = static_cast< int >(val4);
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 (arg1)->SetAttr(arg2,arg3,arg4);
9504 wxPyEndAllowThreads(__tstate);
9505 if (PyErr_Occurred()) SWIG_fail;
9506 }
9507 resultobj = SWIG_Py_Void();
9508 return resultobj;
9509 fail:
9510 return NULL;
9511 }
9512
9513
9514 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9515 PyObject *resultobj = 0;
9516 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9517 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9518 int arg3 ;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 void *argp2 = 0 ;
9522 int res2 = 0 ;
9523 int val3 ;
9524 int ecode3 = 0 ;
9525 PyObject * obj0 = 0 ;
9526 PyObject * obj1 = 0 ;
9527 PyObject * obj2 = 0 ;
9528 char * kwnames[] = {
9529 (char *) "self",(char *) "attr",(char *) "row", NULL
9530 };
9531
9532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9534 if (!SWIG_IsOK(res1)) {
9535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9536 }
9537 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9539 if (!SWIG_IsOK(res2)) {
9540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9541 }
9542 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9543 ecode3 = SWIG_AsVal_int(obj2, &val3);
9544 if (!SWIG_IsOK(ecode3)) {
9545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9546 }
9547 arg3 = static_cast< int >(val3);
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 (arg1)->SetRowAttr(arg2,arg3);
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 resultobj = SWIG_Py_Void();
9555 return resultobj;
9556 fail:
9557 return NULL;
9558 }
9559
9560
9561 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj = 0;
9563 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9564 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9565 int arg3 ;
9566 void *argp1 = 0 ;
9567 int res1 = 0 ;
9568 void *argp2 = 0 ;
9569 int res2 = 0 ;
9570 int val3 ;
9571 int ecode3 = 0 ;
9572 PyObject * obj0 = 0 ;
9573 PyObject * obj1 = 0 ;
9574 PyObject * obj2 = 0 ;
9575 char * kwnames[] = {
9576 (char *) "self",(char *) "attr",(char *) "col", NULL
9577 };
9578
9579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9581 if (!SWIG_IsOK(res1)) {
9582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9583 }
9584 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9586 if (!SWIG_IsOK(res2)) {
9587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9588 }
9589 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9590 ecode3 = SWIG_AsVal_int(obj2, &val3);
9591 if (!SWIG_IsOK(ecode3)) {
9592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9593 }
9594 arg3 = static_cast< int >(val3);
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 (arg1)->SetColAttr(arg2,arg3);
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_Py_Void();
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *obj;
9610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9611 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9612 return SWIG_Py_Void();
9613 }
9614
9615 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616 PyObject *resultobj = 0;
9617 wxPyGridTableBase *result = 0 ;
9618
9619 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9620 {
9621 PyThreadState* __tstate = wxPyBeginAllowThreads();
9622 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 PyObject *arg3 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 PyObject * obj2 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "self",(char *) "_class", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9651 }
9652 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9653 arg2 = obj1;
9654 arg3 = obj2;
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 (arg1)->_setCallbackInfo(arg2,arg3);
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_Py_Void();
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 PyObject *resultobj = 0;
9670 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 PyObject *swig_obj[1] ;
9674
9675 if (!args) SWIG_fail;
9676 swig_obj[0] = args;
9677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9678 if (!SWIG_IsOK(res1)) {
9679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9680 }
9681 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 wxPyGridTableBase_Destroy(arg1);
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_Py_Void();
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *obj;
9697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9698 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9699 return SWIG_Py_Void();
9700 }
9701
9702 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9703 return SWIG_Python_InitShadowInstance(args);
9704 }
9705
9706 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9707 PyObject *resultobj = 0;
9708 int arg1 = (int) 0 ;
9709 int arg2 = (int) 0 ;
9710 wxGridStringTable *result = 0 ;
9711 int val1 ;
9712 int ecode1 = 0 ;
9713 int val2 ;
9714 int ecode2 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 char * kwnames[] = {
9718 (char *) "numRows",(char *) "numCols", NULL
9719 };
9720
9721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9722 if (obj0) {
9723 ecode1 = SWIG_AsVal_int(obj0, &val1);
9724 if (!SWIG_IsOK(ecode1)) {
9725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9726 }
9727 arg1 = static_cast< int >(val1);
9728 }
9729 if (obj1) {
9730 ecode2 = SWIG_AsVal_int(obj1, &val2);
9731 if (!SWIG_IsOK(ecode2)) {
9732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9733 }
9734 arg2 = static_cast< int >(val2);
9735 }
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9750 PyObject *obj;
9751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9752 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9753 return SWIG_Py_Void();
9754 }
9755
9756 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 return SWIG_Python_InitShadowInstance(args);
9758 }
9759
9760 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9761 PyObject *resultobj = 0;
9762 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9763 int arg2 ;
9764 int arg3 = (int) -1 ;
9765 int arg4 = (int) -1 ;
9766 wxGridTableMessage *result = 0 ;
9767 void *argp1 = 0 ;
9768 int res1 = 0 ;
9769 int val2 ;
9770 int ecode2 = 0 ;
9771 int val3 ;
9772 int ecode3 = 0 ;
9773 int val4 ;
9774 int ecode4 = 0 ;
9775 PyObject * obj0 = 0 ;
9776 PyObject * obj1 = 0 ;
9777 PyObject * obj2 = 0 ;
9778 PyObject * obj3 = 0 ;
9779 char * kwnames[] = {
9780 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9781 };
9782
9783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9785 if (!SWIG_IsOK(res1)) {
9786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9787 }
9788 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9789 ecode2 = SWIG_AsVal_int(obj1, &val2);
9790 if (!SWIG_IsOK(ecode2)) {
9791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9792 }
9793 arg2 = static_cast< int >(val2);
9794 if (obj2) {
9795 ecode3 = SWIG_AsVal_int(obj2, &val3);
9796 if (!SWIG_IsOK(ecode3)) {
9797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9798 }
9799 arg3 = static_cast< int >(val3);
9800 }
9801 if (obj3) {
9802 ecode4 = SWIG_AsVal_int(obj3, &val4);
9803 if (!SWIG_IsOK(ecode4)) {
9804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9805 }
9806 arg4 = static_cast< int >(val4);
9807 }
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822 PyObject *resultobj = 0;
9823 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9824 void *argp1 = 0 ;
9825 int res1 = 0 ;
9826 PyObject *swig_obj[1] ;
9827
9828 if (!args) SWIG_fail;
9829 swig_obj[0] = args;
9830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9831 if (!SWIG_IsOK(res1)) {
9832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9833 }
9834 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 delete arg1;
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 resultobj = SWIG_Py_Void();
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9850 PyObject *resultobj = 0;
9851 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9852 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9853 void *argp1 = 0 ;
9854 int res1 = 0 ;
9855 void *argp2 = 0 ;
9856 int res2 = 0 ;
9857 PyObject * obj0 = 0 ;
9858 PyObject * obj1 = 0 ;
9859 char * kwnames[] = {
9860 (char *) "self",(char *) "table", NULL
9861 };
9862
9863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9867 }
9868 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9870 if (!SWIG_IsOK(res2)) {
9871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9872 }
9873 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 (arg1)->SetTableObject(arg2);
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 resultobj = SWIG_Py_Void();
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *resultobj = 0;
9889 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9890 wxGridTableBase *result = 0 ;
9891 void *argp1 = 0 ;
9892 int res1 = 0 ;
9893 PyObject *swig_obj[1] ;
9894
9895 if (!args) SWIG_fail;
9896 swig_obj[0] = args;
9897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9898 if (!SWIG_IsOK(res1)) {
9899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9900 }
9901 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 {
9909 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj = 0;
9919 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9920 int arg2 ;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 int val2 ;
9924 int ecode2 = 0 ;
9925 PyObject * obj0 = 0 ;
9926 PyObject * obj1 = 0 ;
9927 char * kwnames[] = {
9928 (char *) "self",(char *) "id", NULL
9929 };
9930
9931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9933 if (!SWIG_IsOK(res1)) {
9934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9935 }
9936 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9937 ecode2 = SWIG_AsVal_int(obj1, &val2);
9938 if (!SWIG_IsOK(ecode2)) {
9939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9940 }
9941 arg2 = static_cast< int >(val2);
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 (arg1)->SetId(arg2);
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 resultobj = SWIG_Py_Void();
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9956 PyObject *resultobj = 0;
9957 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9958 int result;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject *swig_obj[1] ;
9962
9963 if (!args) SWIG_fail;
9964 swig_obj[0] = args;
9965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9968 }
9969 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = (int)(arg1)->GetId();
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 resultobj = SWIG_From_int(static_cast< int >(result));
9977 return resultobj;
9978 fail:
9979 return NULL;
9980 }
9981
9982
9983 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9984 PyObject *resultobj = 0;
9985 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9986 int arg2 ;
9987 void *argp1 = 0 ;
9988 int res1 = 0 ;
9989 int val2 ;
9990 int ecode2 = 0 ;
9991 PyObject * obj0 = 0 ;
9992 PyObject * obj1 = 0 ;
9993 char * kwnames[] = {
9994 (char *) "self",(char *) "comInt1", NULL
9995 };
9996
9997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9999 if (!SWIG_IsOK(res1)) {
10000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10001 }
10002 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10003 ecode2 = SWIG_AsVal_int(obj1, &val2);
10004 if (!SWIG_IsOK(ecode2)) {
10005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10006 }
10007 arg2 = static_cast< int >(val2);
10008 {
10009 PyThreadState* __tstate = wxPyBeginAllowThreads();
10010 (arg1)->SetCommandInt(arg2);
10011 wxPyEndAllowThreads(__tstate);
10012 if (PyErr_Occurred()) SWIG_fail;
10013 }
10014 resultobj = SWIG_Py_Void();
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10022 PyObject *resultobj = 0;
10023 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10024 int result;
10025 void *argp1 = 0 ;
10026 int res1 = 0 ;
10027 PyObject *swig_obj[1] ;
10028
10029 if (!args) SWIG_fail;
10030 swig_obj[0] = args;
10031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10032 if (!SWIG_IsOK(res1)) {
10033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10034 }
10035 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 result = (int)(arg1)->GetCommandInt();
10039 wxPyEndAllowThreads(__tstate);
10040 if (PyErr_Occurred()) SWIG_fail;
10041 }
10042 resultobj = SWIG_From_int(static_cast< int >(result));
10043 return resultobj;
10044 fail:
10045 return NULL;
10046 }
10047
10048
10049 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj = 0;
10051 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10052 int arg2 ;
10053 void *argp1 = 0 ;
10054 int res1 = 0 ;
10055 int val2 ;
10056 int ecode2 = 0 ;
10057 PyObject * obj0 = 0 ;
10058 PyObject * obj1 = 0 ;
10059 char * kwnames[] = {
10060 (char *) "self",(char *) "comInt2", NULL
10061 };
10062
10063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10065 if (!SWIG_IsOK(res1)) {
10066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10067 }
10068 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10069 ecode2 = SWIG_AsVal_int(obj1, &val2);
10070 if (!SWIG_IsOK(ecode2)) {
10071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10072 }
10073 arg2 = static_cast< int >(val2);
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->SetCommandInt2(arg2);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10088 PyObject *resultobj = 0;
10089 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10090 int result;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 PyObject *swig_obj[1] ;
10094
10095 if (!args) SWIG_fail;
10096 swig_obj[0] = args;
10097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10098 if (!SWIG_IsOK(res1)) {
10099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10100 }
10101 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 result = (int)(arg1)->GetCommandInt2();
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 resultobj = SWIG_From_int(static_cast< int >(result));
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10116 PyObject *obj;
10117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10118 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10119 return SWIG_Py_Void();
10120 }
10121
10122 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10123 return SWIG_Python_InitShadowInstance(args);
10124 }
10125
10126 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10127 PyObject *resultobj = 0;
10128 int arg1 = (int) -1 ;
10129 int arg2 = (int) -1 ;
10130 wxGridCellCoords *result = 0 ;
10131 int val1 ;
10132 int ecode1 = 0 ;
10133 int val2 ;
10134 int ecode2 = 0 ;
10135 PyObject * obj0 = 0 ;
10136 PyObject * obj1 = 0 ;
10137 char * kwnames[] = {
10138 (char *) "r",(char *) "c", NULL
10139 };
10140
10141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10142 if (obj0) {
10143 ecode1 = SWIG_AsVal_int(obj0, &val1);
10144 if (!SWIG_IsOK(ecode1)) {
10145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10146 }
10147 arg1 = static_cast< int >(val1);
10148 }
10149 if (obj1) {
10150 ecode2 = SWIG_AsVal_int(obj1, &val2);
10151 if (!SWIG_IsOK(ecode2)) {
10152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10153 }
10154 arg2 = static_cast< int >(val2);
10155 }
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10163 return resultobj;
10164 fail:
10165 return NULL;
10166 }
10167
10168
10169 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10170 PyObject *resultobj = 0;
10171 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 PyObject *swig_obj[1] ;
10175
10176 if (!args) SWIG_fail;
10177 swig_obj[0] = args;
10178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10181 }
10182 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 delete arg1;
10186
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198 PyObject *resultobj = 0;
10199 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10200 int result;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 PyObject *swig_obj[1] ;
10204
10205 if (!args) SWIG_fail;
10206 swig_obj[0] = args;
10207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10208 if (!SWIG_IsOK(res1)) {
10209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10210 }
10211 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10212 {
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 resultobj = SWIG_From_int(static_cast< int >(result));
10219 return resultobj;
10220 fail:
10221 return NULL;
10222 }
10223
10224
10225 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj = 0;
10227 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10228 int arg2 ;
10229 void *argp1 = 0 ;
10230 int res1 = 0 ;
10231 int val2 ;
10232 int ecode2 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 char * kwnames[] = {
10236 (char *) "self",(char *) "n", NULL
10237 };
10238
10239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10241 if (!SWIG_IsOK(res1)) {
10242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10243 }
10244 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10245 ecode2 = SWIG_AsVal_int(obj1, &val2);
10246 if (!SWIG_IsOK(ecode2)) {
10247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10248 }
10249 arg2 = static_cast< int >(val2);
10250 {
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 (arg1)->SetRow(arg2);
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 resultobj = SWIG_Py_Void();
10257 return resultobj;
10258 fail:
10259 return NULL;
10260 }
10261
10262
10263 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10264 PyObject *resultobj = 0;
10265 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10266 int result;
10267 void *argp1 = 0 ;
10268 int res1 = 0 ;
10269 PyObject *swig_obj[1] ;
10270
10271 if (!args) SWIG_fail;
10272 swig_obj[0] = args;
10273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10274 if (!SWIG_IsOK(res1)) {
10275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10276 }
10277 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 resultobj = SWIG_From_int(static_cast< int >(result));
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj = 0;
10293 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10294 int arg2 ;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 int val2 ;
10298 int ecode2 = 0 ;
10299 PyObject * obj0 = 0 ;
10300 PyObject * obj1 = 0 ;
10301 char * kwnames[] = {
10302 (char *) "self",(char *) "n", NULL
10303 };
10304
10305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10307 if (!SWIG_IsOK(res1)) {
10308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10309 }
10310 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10311 ecode2 = SWIG_AsVal_int(obj1, &val2);
10312 if (!SWIG_IsOK(ecode2)) {
10313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10314 }
10315 arg2 = static_cast< int >(val2);
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 (arg1)->SetCol(arg2);
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 resultobj = SWIG_Py_Void();
10323 return resultobj;
10324 fail:
10325 return NULL;
10326 }
10327
10328
10329 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10330 PyObject *resultobj = 0;
10331 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10332 int arg2 ;
10333 int arg3 ;
10334 void *argp1 = 0 ;
10335 int res1 = 0 ;
10336 int val2 ;
10337 int ecode2 = 0 ;
10338 int val3 ;
10339 int ecode3 = 0 ;
10340 PyObject * obj0 = 0 ;
10341 PyObject * obj1 = 0 ;
10342 PyObject * obj2 = 0 ;
10343 char * kwnames[] = {
10344 (char *) "self",(char *) "row",(char *) "col", NULL
10345 };
10346
10347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10349 if (!SWIG_IsOK(res1)) {
10350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10351 }
10352 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10353 ecode2 = SWIG_AsVal_int(obj1, &val2);
10354 if (!SWIG_IsOK(ecode2)) {
10355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10356 }
10357 arg2 = static_cast< int >(val2);
10358 ecode3 = SWIG_AsVal_int(obj2, &val3);
10359 if (!SWIG_IsOK(ecode3)) {
10360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10361 }
10362 arg3 = static_cast< int >(val3);
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 (arg1)->Set(arg2,arg3);
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 resultobj = SWIG_Py_Void();
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10377 PyObject *resultobj = 0;
10378 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10379 PyObject *arg2 = (PyObject *) 0 ;
10380 bool result;
10381 void *argp1 = 0 ;
10382 int res1 = 0 ;
10383 PyObject * obj0 = 0 ;
10384 PyObject * obj1 = 0 ;
10385 char * kwnames[] = {
10386 (char *) "self",(char *) "other", NULL
10387 };
10388
10389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10391 if (!SWIG_IsOK(res1)) {
10392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10393 }
10394 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10395 arg2 = obj1;
10396 {
10397 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10398 if (PyErr_Occurred()) SWIG_fail;
10399 }
10400 {
10401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10402 }
10403 return resultobj;
10404 fail:
10405 return NULL;
10406 }
10407
10408
10409 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj = 0;
10411 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10412 PyObject *arg2 = (PyObject *) 0 ;
10413 bool result;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 PyObject * obj0 = 0 ;
10417 PyObject * obj1 = 0 ;
10418 char * kwnames[] = {
10419 (char *) "self",(char *) "other", NULL
10420 };
10421
10422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10424 if (!SWIG_IsOK(res1)) {
10425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10426 }
10427 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10428 arg2 = obj1;
10429 {
10430 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 {
10434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10435 }
10436 return resultobj;
10437 fail:
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10443 PyObject *resultobj = 0;
10444 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10445 PyObject *result = 0 ;
10446 void *argp1 = 0 ;
10447 int res1 = 0 ;
10448 PyObject *swig_obj[1] ;
10449
10450 if (!args) SWIG_fail;
10451 swig_obj[0] = args;
10452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10453 if (!SWIG_IsOK(res1)) {
10454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10455 }
10456 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 result = (PyObject *)wxGridCellCoords_Get(arg1);
10460 wxPyEndAllowThreads(__tstate);
10461 if (PyErr_Occurred()) SWIG_fail;
10462 }
10463 resultobj = result;
10464 return resultobj;
10465 fail:
10466 return NULL;
10467 }
10468
10469
10470 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10471 PyObject *obj;
10472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10473 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10474 return SWIG_Py_Void();
10475 }
10476
10477 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10478 return SWIG_Python_InitShadowInstance(args);
10479 }
10480
10481 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10482 PyObject *resultobj = 0;
10483 wxWindow *arg1 = (wxWindow *) 0 ;
10484 int arg2 = (int) -1 ;
10485 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10486 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10487 wxSize const &arg4_defvalue = wxDefaultSize ;
10488 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10489 long arg5 = (long) wxWANTS_CHARS ;
10490 wxString const &arg6_defvalue = wxPyGridNameStr ;
10491 wxString *arg6 = (wxString *) &arg6_defvalue ;
10492 wxGrid *result = 0 ;
10493 void *argp1 = 0 ;
10494 int res1 = 0 ;
10495 int val2 ;
10496 int ecode2 = 0 ;
10497 wxPoint temp3 ;
10498 wxSize temp4 ;
10499 long val5 ;
10500 int ecode5 = 0 ;
10501 bool temp6 = false ;
10502 PyObject * obj0 = 0 ;
10503 PyObject * obj1 = 0 ;
10504 PyObject * obj2 = 0 ;
10505 PyObject * obj3 = 0 ;
10506 PyObject * obj4 = 0 ;
10507 PyObject * obj5 = 0 ;
10508 char * kwnames[] = {
10509 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10510 };
10511
10512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10514 if (!SWIG_IsOK(res1)) {
10515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10516 }
10517 arg1 = reinterpret_cast< wxWindow * >(argp1);
10518 if (obj1) {
10519 ecode2 = SWIG_AsVal_int(obj1, &val2);
10520 if (!SWIG_IsOK(ecode2)) {
10521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10522 }
10523 arg2 = static_cast< int >(val2);
10524 }
10525 if (obj2) {
10526 {
10527 arg3 = &temp3;
10528 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10529 }
10530 }
10531 if (obj3) {
10532 {
10533 arg4 = &temp4;
10534 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10535 }
10536 }
10537 if (obj4) {
10538 ecode5 = SWIG_AsVal_long(obj4, &val5);
10539 if (!SWIG_IsOK(ecode5)) {
10540 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10541 }
10542 arg5 = static_cast< long >(val5);
10543 }
10544 if (obj5) {
10545 {
10546 arg6 = wxString_in_helper(obj5);
10547 if (arg6 == NULL) SWIG_fail;
10548 temp6 = true;
10549 }
10550 }
10551 {
10552 if (!wxPyCheckForApp()) SWIG_fail;
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10559 {
10560 if (temp6)
10561 delete arg6;
10562 }
10563 return resultobj;
10564 fail:
10565 {
10566 if (temp6)
10567 delete arg6;
10568 }
10569 return NULL;
10570 }
10571
10572
10573 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10574 PyObject *resultobj = 0;
10575 wxGrid *result = 0 ;
10576
10577 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10578 {
10579 if (!wxPyCheckForApp()) SWIG_fail;
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = (wxGrid *)new wxGrid();
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10586 return resultobj;
10587 fail:
10588 return NULL;
10589 }
10590
10591
10592 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10593 PyObject *resultobj = 0;
10594 wxGrid *arg1 = (wxGrid *) 0 ;
10595 wxWindow *arg2 = (wxWindow *) 0 ;
10596 int arg3 = (int) -1 ;
10597 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10598 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10599 wxSize const &arg5_defvalue = wxDefaultSize ;
10600 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10601 long arg6 = (long) wxWANTS_CHARS ;
10602 wxString const &arg7_defvalue = wxPyGridNameStr ;
10603 wxString *arg7 = (wxString *) &arg7_defvalue ;
10604 bool result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 void *argp2 = 0 ;
10608 int res2 = 0 ;
10609 int val3 ;
10610 int ecode3 = 0 ;
10611 wxPoint temp4 ;
10612 wxSize temp5 ;
10613 long val6 ;
10614 int ecode6 = 0 ;
10615 bool temp7 = false ;
10616 PyObject * obj0 = 0 ;
10617 PyObject * obj1 = 0 ;
10618 PyObject * obj2 = 0 ;
10619 PyObject * obj3 = 0 ;
10620 PyObject * obj4 = 0 ;
10621 PyObject * obj5 = 0 ;
10622 PyObject * obj6 = 0 ;
10623 char * kwnames[] = {
10624 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10625 };
10626
10627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10629 if (!SWIG_IsOK(res1)) {
10630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10631 }
10632 arg1 = reinterpret_cast< wxGrid * >(argp1);
10633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10634 if (!SWIG_IsOK(res2)) {
10635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10636 }
10637 arg2 = reinterpret_cast< wxWindow * >(argp2);
10638 if (obj2) {
10639 ecode3 = SWIG_AsVal_int(obj2, &val3);
10640 if (!SWIG_IsOK(ecode3)) {
10641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10642 }
10643 arg3 = static_cast< int >(val3);
10644 }
10645 if (obj3) {
10646 {
10647 arg4 = &temp4;
10648 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10649 }
10650 }
10651 if (obj4) {
10652 {
10653 arg5 = &temp5;
10654 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10655 }
10656 }
10657 if (obj5) {
10658 ecode6 = SWIG_AsVal_long(obj5, &val6);
10659 if (!SWIG_IsOK(ecode6)) {
10660 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10661 }
10662 arg6 = static_cast< long >(val6);
10663 }
10664 if (obj6) {
10665 {
10666 arg7 = wxString_in_helper(obj6);
10667 if (arg7 == NULL) SWIG_fail;
10668 temp7 = true;
10669 }
10670 }
10671 {
10672 PyThreadState* __tstate = wxPyBeginAllowThreads();
10673 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10674 wxPyEndAllowThreads(__tstate);
10675 if (PyErr_Occurred()) SWIG_fail;
10676 }
10677 {
10678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10679 }
10680 {
10681 if (temp7)
10682 delete arg7;
10683 }
10684 return resultobj;
10685 fail:
10686 {
10687 if (temp7)
10688 delete arg7;
10689 }
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj = 0;
10696 wxGrid *arg1 = (wxGrid *) 0 ;
10697 int arg2 ;
10698 int arg3 ;
10699 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10700 bool result;
10701 void *argp1 = 0 ;
10702 int res1 = 0 ;
10703 int val2 ;
10704 int ecode2 = 0 ;
10705 int val3 ;
10706 int ecode3 = 0 ;
10707 int val4 ;
10708 int ecode4 = 0 ;
10709 PyObject * obj0 = 0 ;
10710 PyObject * obj1 = 0 ;
10711 PyObject * obj2 = 0 ;
10712 PyObject * obj3 = 0 ;
10713 char * kwnames[] = {
10714 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10715 };
10716
10717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10719 if (!SWIG_IsOK(res1)) {
10720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10721 }
10722 arg1 = reinterpret_cast< wxGrid * >(argp1);
10723 ecode2 = SWIG_AsVal_int(obj1, &val2);
10724 if (!SWIG_IsOK(ecode2)) {
10725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10726 }
10727 arg2 = static_cast< int >(val2);
10728 ecode3 = SWIG_AsVal_int(obj2, &val3);
10729 if (!SWIG_IsOK(ecode3)) {
10730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10731 }
10732 arg3 = static_cast< int >(val3);
10733 if (obj3) {
10734 ecode4 = SWIG_AsVal_int(obj3, &val4);
10735 if (!SWIG_IsOK(ecode4)) {
10736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10737 }
10738 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10739 }
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10748 }
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj = 0;
10757 wxGrid *arg1 = (wxGrid *) 0 ;
10758 WXGRIDSELECTIONMODES arg2 ;
10759 void *argp1 = 0 ;
10760 int res1 = 0 ;
10761 int val2 ;
10762 int ecode2 = 0 ;
10763 PyObject * obj0 = 0 ;
10764 PyObject * obj1 = 0 ;
10765 char * kwnames[] = {
10766 (char *) "self",(char *) "selmode", NULL
10767 };
10768
10769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10771 if (!SWIG_IsOK(res1)) {
10772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10773 }
10774 arg1 = reinterpret_cast< wxGrid * >(argp1);
10775 ecode2 = SWIG_AsVal_int(obj1, &val2);
10776 if (!SWIG_IsOK(ecode2)) {
10777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10778 }
10779 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 (arg1)->SetSelectionMode(arg2);
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 resultobj = SWIG_Py_Void();
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxGrid *arg1 = (wxGrid *) 0 ;
10796 WXGRIDSELECTIONMODES result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 PyObject *swig_obj[1] ;
10800
10801 if (!args) SWIG_fail;
10802 swig_obj[0] = args;
10803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10804 if (!SWIG_IsOK(res1)) {
10805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10806 }
10807 arg1 = reinterpret_cast< wxGrid * >(argp1);
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 resultobj = SWIG_From_int(static_cast< int >(result));
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10822 PyObject *resultobj = 0;
10823 wxGrid *arg1 = (wxGrid *) 0 ;
10824 int result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 PyObject *swig_obj[1] ;
10828
10829 if (!args) SWIG_fail;
10830 swig_obj[0] = args;
10831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10832 if (!SWIG_IsOK(res1)) {
10833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10834 }
10835 arg1 = reinterpret_cast< wxGrid * >(argp1);
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (int)(arg1)->GetNumberRows();
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 resultobj = SWIG_From_int(static_cast< int >(result));
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10850 PyObject *resultobj = 0;
10851 wxGrid *arg1 = (wxGrid *) 0 ;
10852 int result;
10853 void *argp1 = 0 ;
10854 int res1 = 0 ;
10855 PyObject *swig_obj[1] ;
10856
10857 if (!args) SWIG_fail;
10858 swig_obj[0] = args;
10859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10860 if (!SWIG_IsOK(res1)) {
10861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10862 }
10863 arg1 = reinterpret_cast< wxGrid * >(argp1);
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 result = (int)(arg1)->GetNumberCols();
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 resultobj = SWIG_From_int(static_cast< int >(result));
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj = 0;
10879 wxGrid *arg1 = (wxGrid *) 0 ;
10880 wxGridTableMessage *arg2 = 0 ;
10881 bool result;
10882 void *argp1 = 0 ;
10883 int res1 = 0 ;
10884 void *argp2 = 0 ;
10885 int res2 = 0 ;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 char * kwnames[] = {
10889 (char *) "self",(char *)"arg2", NULL
10890 };
10891
10892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10894 if (!SWIG_IsOK(res1)) {
10895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10896 }
10897 arg1 = reinterpret_cast< wxGrid * >(argp1);
10898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10899 if (!SWIG_IsOK(res2)) {
10900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10901 }
10902 if (!argp2) {
10903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10904 }
10905 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10914 }
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922 PyObject *resultobj = 0;
10923 wxGrid *arg1 = (wxGrid *) 0 ;
10924 wxGridTableBase *result = 0 ;
10925 void *argp1 = 0 ;
10926 int res1 = 0 ;
10927 PyObject *swig_obj[1] ;
10928
10929 if (!args) SWIG_fail;
10930 swig_obj[0] = args;
10931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10932 if (!SWIG_IsOK(res1)) {
10933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10934 }
10935 arg1 = reinterpret_cast< wxGrid * >(argp1);
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 {
10943 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10944 }
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxGrid *arg1 = (wxGrid *) 0 ;
10954 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10955 bool arg3 = (bool) false ;
10956 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10957 bool result;
10958 void *argp1 = 0 ;
10959 int res1 = 0 ;
10960 int res2 = 0 ;
10961 bool val3 ;
10962 int ecode3 = 0 ;
10963 int val4 ;
10964 int ecode4 = 0 ;
10965 PyObject * obj0 = 0 ;
10966 PyObject * obj1 = 0 ;
10967 PyObject * obj2 = 0 ;
10968 PyObject * obj3 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10977 }
10978 arg1 = reinterpret_cast< wxGrid * >(argp1);
10979 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10980 if (!SWIG_IsOK(res2)) {
10981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10982 }
10983 if (obj2) {
10984 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10985 if (!SWIG_IsOK(ecode3)) {
10986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10987 }
10988 arg3 = static_cast< bool >(val3);
10989 }
10990 if (obj3) {
10991 ecode4 = SWIG_AsVal_int(obj3, &val4);
10992 if (!SWIG_IsOK(ecode4)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10994 }
10995 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11013 PyObject *resultobj = 0;
11014 wxGrid *arg1 = (wxGrid *) 0 ;
11015 void *argp1 = 0 ;
11016 int res1 = 0 ;
11017 PyObject *swig_obj[1] ;
11018
11019 if (!args) SWIG_fail;
11020 swig_obj[0] = args;
11021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11022 if (!SWIG_IsOK(res1)) {
11023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11024 }
11025 arg1 = reinterpret_cast< wxGrid * >(argp1);
11026 {
11027 PyThreadState* __tstate = wxPyBeginAllowThreads();
11028 (arg1)->ClearGrid();
11029 wxPyEndAllowThreads(__tstate);
11030 if (PyErr_Occurred()) SWIG_fail;
11031 }
11032 resultobj = SWIG_Py_Void();
11033 return resultobj;
11034 fail:
11035 return NULL;
11036 }
11037
11038
11039 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11040 PyObject *resultobj = 0;
11041 wxGrid *arg1 = (wxGrid *) 0 ;
11042 int arg2 = (int) 0 ;
11043 int arg3 = (int) 1 ;
11044 bool arg4 = (bool) true ;
11045 bool result;
11046 void *argp1 = 0 ;
11047 int res1 = 0 ;
11048 int val2 ;
11049 int ecode2 = 0 ;
11050 int val3 ;
11051 int ecode3 = 0 ;
11052 bool val4 ;
11053 int ecode4 = 0 ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 PyObject * obj3 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11066 }
11067 arg1 = reinterpret_cast< wxGrid * >(argp1);
11068 if (obj1) {
11069 ecode2 = SWIG_AsVal_int(obj1, &val2);
11070 if (!SWIG_IsOK(ecode2)) {
11071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11072 }
11073 arg2 = static_cast< int >(val2);
11074 }
11075 if (obj2) {
11076 ecode3 = SWIG_AsVal_int(obj2, &val3);
11077 if (!SWIG_IsOK(ecode3)) {
11078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11079 }
11080 arg3 = static_cast< int >(val3);
11081 }
11082 if (obj3) {
11083 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11084 if (!SWIG_IsOK(ecode4)) {
11085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11086 }
11087 arg4 = static_cast< bool >(val4);
11088 }
11089 {
11090 PyThreadState* __tstate = wxPyBeginAllowThreads();
11091 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11105 PyObject *resultobj = 0;
11106 wxGrid *arg1 = (wxGrid *) 0 ;
11107 int arg2 = (int) 1 ;
11108 bool arg3 = (bool) true ;
11109 bool result;
11110 void *argp1 = 0 ;
11111 int res1 = 0 ;
11112 int val2 ;
11113 int ecode2 = 0 ;
11114 bool val3 ;
11115 int ecode3 = 0 ;
11116 PyObject * obj0 = 0 ;
11117 PyObject * obj1 = 0 ;
11118 PyObject * obj2 = 0 ;
11119 char * kwnames[] = {
11120 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11121 };
11122
11123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11125 if (!SWIG_IsOK(res1)) {
11126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11127 }
11128 arg1 = reinterpret_cast< wxGrid * >(argp1);
11129 if (obj1) {
11130 ecode2 = SWIG_AsVal_int(obj1, &val2);
11131 if (!SWIG_IsOK(ecode2)) {
11132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11133 }
11134 arg2 = static_cast< int >(val2);
11135 }
11136 if (obj2) {
11137 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11138 if (!SWIG_IsOK(ecode3)) {
11139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11140 }
11141 arg3 = static_cast< bool >(val3);
11142 }
11143 {
11144 PyThreadState* __tstate = wxPyBeginAllowThreads();
11145 result = (bool)(arg1)->AppendRows(arg2,arg3);
11146 wxPyEndAllowThreads(__tstate);
11147 if (PyErr_Occurred()) SWIG_fail;
11148 }
11149 {
11150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11151 }
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj = 0;
11160 wxGrid *arg1 = (wxGrid *) 0 ;
11161 int arg2 = (int) 0 ;
11162 int arg3 = (int) 1 ;
11163 bool arg4 = (bool) true ;
11164 bool result;
11165 void *argp1 = 0 ;
11166 int res1 = 0 ;
11167 int val2 ;
11168 int ecode2 = 0 ;
11169 int val3 ;
11170 int ecode3 = 0 ;
11171 bool val4 ;
11172 int ecode4 = 0 ;
11173 PyObject * obj0 = 0 ;
11174 PyObject * obj1 = 0 ;
11175 PyObject * obj2 = 0 ;
11176 PyObject * obj3 = 0 ;
11177 char * kwnames[] = {
11178 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11179 };
11180
11181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11183 if (!SWIG_IsOK(res1)) {
11184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11185 }
11186 arg1 = reinterpret_cast< wxGrid * >(argp1);
11187 if (obj1) {
11188 ecode2 = SWIG_AsVal_int(obj1, &val2);
11189 if (!SWIG_IsOK(ecode2)) {
11190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11191 }
11192 arg2 = static_cast< int >(val2);
11193 }
11194 if (obj2) {
11195 ecode3 = SWIG_AsVal_int(obj2, &val3);
11196 if (!SWIG_IsOK(ecode3)) {
11197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11198 }
11199 arg3 = static_cast< int >(val3);
11200 }
11201 if (obj3) {
11202 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11203 if (!SWIG_IsOK(ecode4)) {
11204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11205 }
11206 arg4 = static_cast< bool >(val4);
11207 }
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 {
11215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11216 }
11217 return resultobj;
11218 fail:
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj = 0;
11225 wxGrid *arg1 = (wxGrid *) 0 ;
11226 int arg2 = (int) 0 ;
11227 int arg3 = (int) 1 ;
11228 bool arg4 = (bool) true ;
11229 bool result;
11230 void *argp1 = 0 ;
11231 int res1 = 0 ;
11232 int val2 ;
11233 int ecode2 = 0 ;
11234 int val3 ;
11235 int ecode3 = 0 ;
11236 bool val4 ;
11237 int ecode4 = 0 ;
11238 PyObject * obj0 = 0 ;
11239 PyObject * obj1 = 0 ;
11240 PyObject * obj2 = 0 ;
11241 PyObject * obj3 = 0 ;
11242 char * kwnames[] = {
11243 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11244 };
11245
11246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11248 if (!SWIG_IsOK(res1)) {
11249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11250 }
11251 arg1 = reinterpret_cast< wxGrid * >(argp1);
11252 if (obj1) {
11253 ecode2 = SWIG_AsVal_int(obj1, &val2);
11254 if (!SWIG_IsOK(ecode2)) {
11255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11256 }
11257 arg2 = static_cast< int >(val2);
11258 }
11259 if (obj2) {
11260 ecode3 = SWIG_AsVal_int(obj2, &val3);
11261 if (!SWIG_IsOK(ecode3)) {
11262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11263 }
11264 arg3 = static_cast< int >(val3);
11265 }
11266 if (obj3) {
11267 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11268 if (!SWIG_IsOK(ecode4)) {
11269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11270 }
11271 arg4 = static_cast< bool >(val4);
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11281 }
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj = 0;
11290 wxGrid *arg1 = (wxGrid *) 0 ;
11291 int arg2 = (int) 1 ;
11292 bool arg3 = (bool) true ;
11293 bool result;
11294 void *argp1 = 0 ;
11295 int res1 = 0 ;
11296 int val2 ;
11297 int ecode2 = 0 ;
11298 bool val3 ;
11299 int ecode3 = 0 ;
11300 PyObject * obj0 = 0 ;
11301 PyObject * obj1 = 0 ;
11302 PyObject * obj2 = 0 ;
11303 char * kwnames[] = {
11304 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11305 };
11306
11307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11309 if (!SWIG_IsOK(res1)) {
11310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11311 }
11312 arg1 = reinterpret_cast< wxGrid * >(argp1);
11313 if (obj1) {
11314 ecode2 = SWIG_AsVal_int(obj1, &val2);
11315 if (!SWIG_IsOK(ecode2)) {
11316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11317 }
11318 arg2 = static_cast< int >(val2);
11319 }
11320 if (obj2) {
11321 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11322 if (!SWIG_IsOK(ecode3)) {
11323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11324 }
11325 arg3 = static_cast< bool >(val3);
11326 }
11327 {
11328 PyThreadState* __tstate = wxPyBeginAllowThreads();
11329 result = (bool)(arg1)->AppendCols(arg2,arg3);
11330 wxPyEndAllowThreads(__tstate);
11331 if (PyErr_Occurred()) SWIG_fail;
11332 }
11333 {
11334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11335 }
11336 return resultobj;
11337 fail:
11338 return NULL;
11339 }
11340
11341
11342 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11343 PyObject *resultobj = 0;
11344 wxGrid *arg1 = (wxGrid *) 0 ;
11345 int arg2 = (int) 0 ;
11346 int arg3 = (int) 1 ;
11347 bool arg4 = (bool) true ;
11348 bool result;
11349 void *argp1 = 0 ;
11350 int res1 = 0 ;
11351 int val2 ;
11352 int ecode2 = 0 ;
11353 int val3 ;
11354 int ecode3 = 0 ;
11355 bool val4 ;
11356 int ecode4 = 0 ;
11357 PyObject * obj0 = 0 ;
11358 PyObject * obj1 = 0 ;
11359 PyObject * obj2 = 0 ;
11360 PyObject * obj3 = 0 ;
11361 char * kwnames[] = {
11362 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11363 };
11364
11365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11367 if (!SWIG_IsOK(res1)) {
11368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11369 }
11370 arg1 = reinterpret_cast< wxGrid * >(argp1);
11371 if (obj1) {
11372 ecode2 = SWIG_AsVal_int(obj1, &val2);
11373 if (!SWIG_IsOK(ecode2)) {
11374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11375 }
11376 arg2 = static_cast< int >(val2);
11377 }
11378 if (obj2) {
11379 ecode3 = SWIG_AsVal_int(obj2, &val3);
11380 if (!SWIG_IsOK(ecode3)) {
11381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11382 }
11383 arg3 = static_cast< int >(val3);
11384 }
11385 if (obj3) {
11386 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11387 if (!SWIG_IsOK(ecode4)) {
11388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11389 }
11390 arg4 = static_cast< bool >(val4);
11391 }
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj = 0;
11409 wxGrid *arg1 = (wxGrid *) 0 ;
11410 wxDC *arg2 = 0 ;
11411 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11412 void *argp1 = 0 ;
11413 int res1 = 0 ;
11414 void *argp2 = 0 ;
11415 int res2 = 0 ;
11416 void *argp3 = 0 ;
11417 int res3 = 0 ;
11418 PyObject * obj0 = 0 ;
11419 PyObject * obj1 = 0 ;
11420 PyObject * obj2 = 0 ;
11421 char * kwnames[] = {
11422 (char *) "self",(char *) "dc",(char *) "attr", NULL
11423 };
11424
11425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11427 if (!SWIG_IsOK(res1)) {
11428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11429 }
11430 arg1 = reinterpret_cast< wxGrid * >(argp1);
11431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11432 if (!SWIG_IsOK(res2)) {
11433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11434 }
11435 if (!argp2) {
11436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11437 }
11438 arg2 = reinterpret_cast< wxDC * >(argp2);
11439 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11440 if (!SWIG_IsOK(res3)) {
11441 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11442 }
11443 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 resultobj = SWIG_Py_Void();
11451 return resultobj;
11452 fail:
11453 return NULL;
11454 }
11455
11456
11457 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11458 PyObject *resultobj = 0;
11459 wxGrid *arg1 = (wxGrid *) 0 ;
11460 wxDC *arg2 = 0 ;
11461 wxString *arg3 = 0 ;
11462 wxRect *arg4 = 0 ;
11463 int arg5 = (int) wxLEFT ;
11464 int arg6 = (int) wxTOP ;
11465 int arg7 = (int) wxHORIZONTAL ;
11466 void *argp1 = 0 ;
11467 int res1 = 0 ;
11468 void *argp2 = 0 ;
11469 int res2 = 0 ;
11470 bool temp3 = false ;
11471 wxRect temp4 ;
11472 int val5 ;
11473 int ecode5 = 0 ;
11474 int val6 ;
11475 int ecode6 = 0 ;
11476 int val7 ;
11477 int ecode7 = 0 ;
11478 PyObject * obj0 = 0 ;
11479 PyObject * obj1 = 0 ;
11480 PyObject * obj2 = 0 ;
11481 PyObject * obj3 = 0 ;
11482 PyObject * obj4 = 0 ;
11483 PyObject * obj5 = 0 ;
11484 PyObject * obj6 = 0 ;
11485 char * kwnames[] = {
11486 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11487 };
11488
11489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11493 }
11494 arg1 = reinterpret_cast< wxGrid * >(argp1);
11495 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11496 if (!SWIG_IsOK(res2)) {
11497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11498 }
11499 if (!argp2) {
11500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11501 }
11502 arg2 = reinterpret_cast< wxDC * >(argp2);
11503 {
11504 arg3 = wxString_in_helper(obj2);
11505 if (arg3 == NULL) SWIG_fail;
11506 temp3 = true;
11507 }
11508 {
11509 arg4 = &temp4;
11510 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11511 }
11512 if (obj4) {
11513 ecode5 = SWIG_AsVal_int(obj4, &val5);
11514 if (!SWIG_IsOK(ecode5)) {
11515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11516 }
11517 arg5 = static_cast< int >(val5);
11518 }
11519 if (obj5) {
11520 ecode6 = SWIG_AsVal_int(obj5, &val6);
11521 if (!SWIG_IsOK(ecode6)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11523 }
11524 arg6 = static_cast< int >(val6);
11525 }
11526 if (obj6) {
11527 ecode7 = SWIG_AsVal_int(obj6, &val7);
11528 if (!SWIG_IsOK(ecode7)) {
11529 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11530 }
11531 arg7 = static_cast< int >(val7);
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 resultobj = SWIG_Py_Void();
11540 {
11541 if (temp3)
11542 delete arg3;
11543 }
11544 return resultobj;
11545 fail:
11546 {
11547 if (temp3)
11548 delete arg3;
11549 }
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11555 PyObject *resultobj = 0;
11556 wxGrid *arg1 = (wxGrid *) 0 ;
11557 wxDC *arg2 = 0 ;
11558 wxArrayString *arg3 = 0 ;
11559 long *arg4 = (long *) 0 ;
11560 long *arg5 = (long *) 0 ;
11561 void *argp1 = 0 ;
11562 int res1 = 0 ;
11563 void *argp2 = 0 ;
11564 int res2 = 0 ;
11565 bool temp3 = false ;
11566 long temp4 ;
11567 int res4 = SWIG_TMPOBJ ;
11568 long temp5 ;
11569 int res5 = SWIG_TMPOBJ ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 char * kwnames[] = {
11574 (char *) "self",(char *) "dc",(char *) "lines", NULL
11575 };
11576
11577 arg4 = &temp4;
11578 arg5 = &temp5;
11579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11581 if (!SWIG_IsOK(res1)) {
11582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11583 }
11584 arg1 = reinterpret_cast< wxGrid * >(argp1);
11585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11586 if (!SWIG_IsOK(res2)) {
11587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11588 }
11589 if (!argp2) {
11590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11591 }
11592 arg2 = reinterpret_cast< wxDC * >(argp2);
11593 {
11594 if (! PySequence_Check(obj2)) {
11595 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11596 SWIG_fail;
11597 }
11598 arg3 = new wxArrayString;
11599 temp3 = true;
11600 int i, len=PySequence_Length(obj2);
11601 for (i=0; i<len; i++) {
11602 PyObject* item = PySequence_GetItem(obj2, i);
11603 wxString* s = wxString_in_helper(item);
11604 if (PyErr_Occurred()) SWIG_fail;
11605 arg3->Add(*s);
11606 delete s;
11607 Py_DECREF(item);
11608 }
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 resultobj = SWIG_Py_Void();
11617 if (SWIG_IsTmpObj(res4)) {
11618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11619 } else {
11620 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11622 }
11623 if (SWIG_IsTmpObj(res5)) {
11624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11625 } else {
11626 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11628 }
11629 {
11630 if (temp3) delete arg3;
11631 }
11632 return resultobj;
11633 fail:
11634 {
11635 if (temp3) delete arg3;
11636 }
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 PyObject *resultobj = 0;
11643 wxGrid *arg1 = (wxGrid *) 0 ;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 PyObject *swig_obj[1] ;
11647
11648 if (!args) SWIG_fail;
11649 swig_obj[0] = args;
11650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11651 if (!SWIG_IsOK(res1)) {
11652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11653 }
11654 arg1 = reinterpret_cast< wxGrid * >(argp1);
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 (arg1)->BeginBatch();
11658 wxPyEndAllowThreads(__tstate);
11659 if (PyErr_Occurred()) SWIG_fail;
11660 }
11661 resultobj = SWIG_Py_Void();
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *resultobj = 0;
11670 wxGrid *arg1 = (wxGrid *) 0 ;
11671 void *argp1 = 0 ;
11672 int res1 = 0 ;
11673 PyObject *swig_obj[1] ;
11674
11675 if (!args) SWIG_fail;
11676 swig_obj[0] = args;
11677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11680 }
11681 arg1 = reinterpret_cast< wxGrid * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 (arg1)->EndBatch();
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_Py_Void();
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 PyObject *resultobj = 0;
11697 wxGrid *arg1 = (wxGrid *) 0 ;
11698 int result;
11699 void *argp1 = 0 ;
11700 int res1 = 0 ;
11701 PyObject *swig_obj[1] ;
11702
11703 if (!args) SWIG_fail;
11704 swig_obj[0] = args;
11705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11708 }
11709 arg1 = reinterpret_cast< wxGrid * >(argp1);
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (int)(arg1)->GetBatchCount();
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 resultobj = SWIG_From_int(static_cast< int >(result));
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxGrid *arg1 = (wxGrid *) 0 ;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11735 }
11736 arg1 = reinterpret_cast< wxGrid * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 (arg1)->ForceRefresh();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_Py_Void();
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxGrid *arg1 = (wxGrid *) 0 ;
11753 bool result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11763 }
11764 arg1 = reinterpret_cast< wxGrid * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (bool)(arg1)->IsEditable();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 {
11772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11773 }
11774 return resultobj;
11775 fail:
11776 return NULL;
11777 }
11778
11779
11780 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11781 PyObject *resultobj = 0;
11782 wxGrid *arg1 = (wxGrid *) 0 ;
11783 bool arg2 ;
11784 void *argp1 = 0 ;
11785 int res1 = 0 ;
11786 bool val2 ;
11787 int ecode2 = 0 ;
11788 PyObject * obj0 = 0 ;
11789 PyObject * obj1 = 0 ;
11790 char * kwnames[] = {
11791 (char *) "self",(char *) "edit", NULL
11792 };
11793
11794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11796 if (!SWIG_IsOK(res1)) {
11797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11798 }
11799 arg1 = reinterpret_cast< wxGrid * >(argp1);
11800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11801 if (!SWIG_IsOK(ecode2)) {
11802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11803 }
11804 arg2 = static_cast< bool >(val2);
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 (arg1)->EnableEditing(arg2);
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_Py_Void();
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11819 PyObject *resultobj = 0;
11820 wxGrid *arg1 = (wxGrid *) 0 ;
11821 bool arg2 = (bool) true ;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 bool val2 ;
11825 int ecode2 = 0 ;
11826 PyObject * obj0 = 0 ;
11827 PyObject * obj1 = 0 ;
11828 char * kwnames[] = {
11829 (char *) "self",(char *) "enable", NULL
11830 };
11831
11832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11834 if (!SWIG_IsOK(res1)) {
11835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11836 }
11837 arg1 = reinterpret_cast< wxGrid * >(argp1);
11838 if (obj1) {
11839 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11840 if (!SWIG_IsOK(ecode2)) {
11841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11842 }
11843 arg2 = static_cast< bool >(val2);
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 (arg1)->EnableCellEditControl(arg2);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 resultobj = SWIG_Py_Void();
11852 return resultobj;
11853 fail:
11854 return NULL;
11855 }
11856
11857
11858 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11859 PyObject *resultobj = 0;
11860 wxGrid *arg1 = (wxGrid *) 0 ;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 PyObject *swig_obj[1] ;
11864
11865 if (!args) SWIG_fail;
11866 swig_obj[0] = args;
11867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11868 if (!SWIG_IsOK(res1)) {
11869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11870 }
11871 arg1 = reinterpret_cast< wxGrid * >(argp1);
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 (arg1)->DisableCellEditControl();
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 resultobj = SWIG_Py_Void();
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886 PyObject *resultobj = 0;
11887 wxGrid *arg1 = (wxGrid *) 0 ;
11888 bool result;
11889 void *argp1 = 0 ;
11890 int res1 = 0 ;
11891 PyObject *swig_obj[1] ;
11892
11893 if (!args) SWIG_fail;
11894 swig_obj[0] = args;
11895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11896 if (!SWIG_IsOK(res1)) {
11897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11898 }
11899 arg1 = reinterpret_cast< wxGrid * >(argp1);
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11908 }
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11916 PyObject *resultobj = 0;
11917 wxGrid *arg1 = (wxGrid *) 0 ;
11918 bool result;
11919 void *argp1 = 0 ;
11920 int res1 = 0 ;
11921 PyObject *swig_obj[1] ;
11922
11923 if (!args) SWIG_fail;
11924 swig_obj[0] = args;
11925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11926 if (!SWIG_IsOK(res1)) {
11927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11928 }
11929 arg1 = reinterpret_cast< wxGrid * >(argp1);
11930 {
11931 PyThreadState* __tstate = wxPyBeginAllowThreads();
11932 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11933 wxPyEndAllowThreads(__tstate);
11934 if (PyErr_Occurred()) SWIG_fail;
11935 }
11936 {
11937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11938 }
11939 return resultobj;
11940 fail:
11941 return NULL;
11942 }
11943
11944
11945 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 PyObject *resultobj = 0;
11947 wxGrid *arg1 = (wxGrid *) 0 ;
11948 bool result;
11949 void *argp1 = 0 ;
11950 int res1 = 0 ;
11951 PyObject *swig_obj[1] ;
11952
11953 if (!args) SWIG_fail;
11954 swig_obj[0] = args;
11955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11956 if (!SWIG_IsOK(res1)) {
11957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11958 }
11959 arg1 = reinterpret_cast< wxGrid * >(argp1);
11960 {
11961 PyThreadState* __tstate = wxPyBeginAllowThreads();
11962 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 PyObject *resultobj = 0;
11977 wxGrid *arg1 = (wxGrid *) 0 ;
11978 bool result;
11979 void *argp1 = 0 ;
11980 int res1 = 0 ;
11981 PyObject *swig_obj[1] ;
11982
11983 if (!args) SWIG_fail;
11984 swig_obj[0] = args;
11985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11988 }
11989 arg1 = reinterpret_cast< wxGrid * >(argp1);
11990 {
11991 PyThreadState* __tstate = wxPyBeginAllowThreads();
11992 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11993 wxPyEndAllowThreads(__tstate);
11994 if (PyErr_Occurred()) SWIG_fail;
11995 }
11996 {
11997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11998 }
11999 return resultobj;
12000 fail:
12001 return NULL;
12002 }
12003
12004
12005 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12006 PyObject *resultobj = 0;
12007 wxGrid *arg1 = (wxGrid *) 0 ;
12008 void *argp1 = 0 ;
12009 int res1 = 0 ;
12010 PyObject *swig_obj[1] ;
12011
12012 if (!args) SWIG_fail;
12013 swig_obj[0] = args;
12014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12017 }
12018 arg1 = reinterpret_cast< wxGrid * >(argp1);
12019 {
12020 PyThreadState* __tstate = wxPyBeginAllowThreads();
12021 (arg1)->ShowCellEditControl();
12022 wxPyEndAllowThreads(__tstate);
12023 if (PyErr_Occurred()) SWIG_fail;
12024 }
12025 resultobj = SWIG_Py_Void();
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *resultobj = 0;
12034 wxGrid *arg1 = (wxGrid *) 0 ;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 PyObject *swig_obj[1] ;
12038
12039 if (!args) SWIG_fail;
12040 swig_obj[0] = args;
12041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12044 }
12045 arg1 = reinterpret_cast< wxGrid * >(argp1);
12046 {
12047 PyThreadState* __tstate = wxPyBeginAllowThreads();
12048 (arg1)->HideCellEditControl();
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 resultobj = SWIG_Py_Void();
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12060 PyObject *resultobj = 0;
12061 wxGrid *arg1 = (wxGrid *) 0 ;
12062 void *argp1 = 0 ;
12063 int res1 = 0 ;
12064 PyObject *swig_obj[1] ;
12065
12066 if (!args) SWIG_fail;
12067 swig_obj[0] = args;
12068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12069 if (!SWIG_IsOK(res1)) {
12070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12071 }
12072 arg1 = reinterpret_cast< wxGrid * >(argp1);
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 (arg1)->SaveEditControlValue();
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 resultobj = SWIG_Py_Void();
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj = 0;
12088 wxGrid *arg1 = (wxGrid *) 0 ;
12089 int arg2 ;
12090 int arg3 ;
12091 wxGridCellCoords result;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 int val2 ;
12095 int ecode2 = 0 ;
12096 int val3 ;
12097 int ecode3 = 0 ;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 PyObject * obj2 = 0 ;
12101 char * kwnames[] = {
12102 (char *) "self",(char *) "x",(char *) "y", NULL
12103 };
12104
12105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12107 if (!SWIG_IsOK(res1)) {
12108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12109 }
12110 arg1 = reinterpret_cast< wxGrid * >(argp1);
12111 ecode2 = SWIG_AsVal_int(obj1, &val2);
12112 if (!SWIG_IsOK(ecode2)) {
12113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12114 }
12115 arg2 = static_cast< int >(val2);
12116 ecode3 = SWIG_AsVal_int(obj2, &val3);
12117 if (!SWIG_IsOK(ecode3)) {
12118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12119 }
12120 arg3 = static_cast< int >(val3);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = wxGrid_XYToCell(arg1,arg2,arg3);
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj = 0;
12136 wxGrid *arg1 = (wxGrid *) 0 ;
12137 int arg2 ;
12138 int result;
12139 void *argp1 = 0 ;
12140 int res1 = 0 ;
12141 int val2 ;
12142 int ecode2 = 0 ;
12143 PyObject * obj0 = 0 ;
12144 PyObject * obj1 = 0 ;
12145 char * kwnames[] = {
12146 (char *) "self",(char *) "y", NULL
12147 };
12148
12149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12153 }
12154 arg1 = reinterpret_cast< wxGrid * >(argp1);
12155 ecode2 = SWIG_AsVal_int(obj1, &val2);
12156 if (!SWIG_IsOK(ecode2)) {
12157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12158 }
12159 arg2 = static_cast< int >(val2);
12160 {
12161 PyThreadState* __tstate = wxPyBeginAllowThreads();
12162 result = (int)(arg1)->YToRow(arg2);
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 resultobj = SWIG_From_int(static_cast< int >(result));
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj = 0;
12175 wxGrid *arg1 = (wxGrid *) 0 ;
12176 int arg2 ;
12177 bool arg3 = (bool) false ;
12178 int result;
12179 void *argp1 = 0 ;
12180 int res1 = 0 ;
12181 int val2 ;
12182 int ecode2 = 0 ;
12183 bool val3 ;
12184 int ecode3 = 0 ;
12185 PyObject * obj0 = 0 ;
12186 PyObject * obj1 = 0 ;
12187 PyObject * obj2 = 0 ;
12188 char * kwnames[] = {
12189 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12190 };
12191
12192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12194 if (!SWIG_IsOK(res1)) {
12195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12196 }
12197 arg1 = reinterpret_cast< wxGrid * >(argp1);
12198 ecode2 = SWIG_AsVal_int(obj1, &val2);
12199 if (!SWIG_IsOK(ecode2)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12201 }
12202 arg2 = static_cast< int >(val2);
12203 if (obj2) {
12204 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12205 if (!SWIG_IsOK(ecode3)) {
12206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12207 }
12208 arg3 = static_cast< bool >(val3);
12209 }
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (int)(arg1)->XToCol(arg2,arg3);
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = SWIG_From_int(static_cast< int >(result));
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj = 0;
12225 wxGrid *arg1 = (wxGrid *) 0 ;
12226 int arg2 ;
12227 int result;
12228 void *argp1 = 0 ;
12229 int res1 = 0 ;
12230 int val2 ;
12231 int ecode2 = 0 ;
12232 PyObject * obj0 = 0 ;
12233 PyObject * obj1 = 0 ;
12234 char * kwnames[] = {
12235 (char *) "self",(char *) "y", NULL
12236 };
12237
12238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12240 if (!SWIG_IsOK(res1)) {
12241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12242 }
12243 arg1 = reinterpret_cast< wxGrid * >(argp1);
12244 ecode2 = SWIG_AsVal_int(obj1, &val2);
12245 if (!SWIG_IsOK(ecode2)) {
12246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12247 }
12248 arg2 = static_cast< int >(val2);
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (int)(arg1)->YToEdgeOfRow(arg2);
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 resultobj = SWIG_From_int(static_cast< int >(result));
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 wxGrid *arg1 = (wxGrid *) 0 ;
12265 int arg2 ;
12266 int result;
12267 void *argp1 = 0 ;
12268 int res1 = 0 ;
12269 int val2 ;
12270 int ecode2 = 0 ;
12271 PyObject * obj0 = 0 ;
12272 PyObject * obj1 = 0 ;
12273 char * kwnames[] = {
12274 (char *) "self",(char *) "x", NULL
12275 };
12276
12277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12281 }
12282 arg1 = reinterpret_cast< wxGrid * >(argp1);
12283 ecode2 = SWIG_AsVal_int(obj1, &val2);
12284 if (!SWIG_IsOK(ecode2)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12286 }
12287 arg2 = static_cast< int >(val2);
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (int)(arg1)->XToEdgeOfCol(arg2);
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = SWIG_From_int(static_cast< int >(result));
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj = 0;
12303 wxGrid *arg1 = (wxGrid *) 0 ;
12304 int arg2 ;
12305 int arg3 ;
12306 wxRect result;
12307 void *argp1 = 0 ;
12308 int res1 = 0 ;
12309 int val2 ;
12310 int ecode2 = 0 ;
12311 int val3 ;
12312 int ecode3 = 0 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 PyObject * obj2 = 0 ;
12316 char * kwnames[] = {
12317 (char *) "self",(char *) "row",(char *) "col", NULL
12318 };
12319
12320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12324 }
12325 arg1 = reinterpret_cast< wxGrid * >(argp1);
12326 ecode2 = SWIG_AsVal_int(obj1, &val2);
12327 if (!SWIG_IsOK(ecode2)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12329 }
12330 arg2 = static_cast< int >(val2);
12331 ecode3 = SWIG_AsVal_int(obj2, &val3);
12332 if (!SWIG_IsOK(ecode3)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12334 }
12335 arg3 = static_cast< int >(val3);
12336 {
12337 PyThreadState* __tstate = wxPyBeginAllowThreads();
12338 result = (arg1)->CellToRect(arg2,arg3);
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12350 PyObject *resultobj = 0;
12351 wxGrid *arg1 = (wxGrid *) 0 ;
12352 int result;
12353 void *argp1 = 0 ;
12354 int res1 = 0 ;
12355 PyObject *swig_obj[1] ;
12356
12357 if (!args) SWIG_fail;
12358 swig_obj[0] = args;
12359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12360 if (!SWIG_IsOK(res1)) {
12361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12362 }
12363 arg1 = reinterpret_cast< wxGrid * >(argp1);
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 result = (int)(arg1)->GetGridCursorRow();
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_From_int(static_cast< int >(result));
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378 PyObject *resultobj = 0;
12379 wxGrid *arg1 = (wxGrid *) 0 ;
12380 int result;
12381 void *argp1 = 0 ;
12382 int res1 = 0 ;
12383 PyObject *swig_obj[1] ;
12384
12385 if (!args) SWIG_fail;
12386 swig_obj[0] = args;
12387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12388 if (!SWIG_IsOK(res1)) {
12389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12390 }
12391 arg1 = reinterpret_cast< wxGrid * >(argp1);
12392 {
12393 PyThreadState* __tstate = wxPyBeginAllowThreads();
12394 result = (int)(arg1)->GetGridCursorCol();
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 resultobj = SWIG_From_int(static_cast< int >(result));
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj = 0;
12407 wxGrid *arg1 = (wxGrid *) 0 ;
12408 int arg2 ;
12409 int arg3 ;
12410 bool arg4 = (bool) true ;
12411 bool result;
12412 void *argp1 = 0 ;
12413 int res1 = 0 ;
12414 int val2 ;
12415 int ecode2 = 0 ;
12416 int val3 ;
12417 int ecode3 = 0 ;
12418 bool val4 ;
12419 int ecode4 = 0 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 PyObject * obj2 = 0 ;
12423 PyObject * obj3 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12426 };
12427
12428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12432 }
12433 arg1 = reinterpret_cast< wxGrid * >(argp1);
12434 ecode2 = SWIG_AsVal_int(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12437 }
12438 arg2 = static_cast< int >(val2);
12439 ecode3 = SWIG_AsVal_int(obj2, &val3);
12440 if (!SWIG_IsOK(ecode3)) {
12441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12442 }
12443 arg3 = static_cast< int >(val3);
12444 if (obj3) {
12445 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12446 if (!SWIG_IsOK(ecode4)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12448 }
12449 arg4 = static_cast< bool >(val4);
12450 }
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12459 }
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj = 0;
12468 wxGrid *arg1 = (wxGrid *) 0 ;
12469 int arg2 ;
12470 int arg3 ;
12471 void *argp1 = 0 ;
12472 int res1 = 0 ;
12473 int val2 ;
12474 int ecode2 = 0 ;
12475 int val3 ;
12476 int ecode3 = 0 ;
12477 PyObject * obj0 = 0 ;
12478 PyObject * obj1 = 0 ;
12479 PyObject * obj2 = 0 ;
12480 char * kwnames[] = {
12481 (char *) "self",(char *) "row",(char *) "col", NULL
12482 };
12483
12484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12488 }
12489 arg1 = reinterpret_cast< wxGrid * >(argp1);
12490 ecode2 = SWIG_AsVal_int(obj1, &val2);
12491 if (!SWIG_IsOK(ecode2)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12493 }
12494 arg2 = static_cast< int >(val2);
12495 ecode3 = SWIG_AsVal_int(obj2, &val3);
12496 if (!SWIG_IsOK(ecode3)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12498 }
12499 arg3 = static_cast< int >(val3);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 (arg1)->MakeCellVisible(arg2,arg3);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_Py_Void();
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxGrid *arg1 = (wxGrid *) 0 ;
12516 int arg2 ;
12517 int arg3 ;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 int val2 ;
12521 int ecode2 = 0 ;
12522 int val3 ;
12523 int ecode3 = 0 ;
12524 PyObject * obj0 = 0 ;
12525 PyObject * obj1 = 0 ;
12526 PyObject * obj2 = 0 ;
12527 char * kwnames[] = {
12528 (char *) "self",(char *) "row",(char *) "col", NULL
12529 };
12530
12531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12533 if (!SWIG_IsOK(res1)) {
12534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12535 }
12536 arg1 = reinterpret_cast< wxGrid * >(argp1);
12537 ecode2 = SWIG_AsVal_int(obj1, &val2);
12538 if (!SWIG_IsOK(ecode2)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12540 }
12541 arg2 = static_cast< int >(val2);
12542 ecode3 = SWIG_AsVal_int(obj2, &val3);
12543 if (!SWIG_IsOK(ecode3)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12545 }
12546 arg3 = static_cast< int >(val3);
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 (arg1)->SetGridCursor(arg2,arg3);
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 resultobj = SWIG_Py_Void();
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj = 0;
12562 wxGrid *arg1 = (wxGrid *) 0 ;
12563 bool arg2 ;
12564 bool result;
12565 void *argp1 = 0 ;
12566 int res1 = 0 ;
12567 bool val2 ;
12568 int ecode2 = 0 ;
12569 PyObject * obj0 = 0 ;
12570 PyObject * obj1 = 0 ;
12571 char * kwnames[] = {
12572 (char *) "self",(char *) "expandSelection", NULL
12573 };
12574
12575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12577 if (!SWIG_IsOK(res1)) {
12578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12579 }
12580 arg1 = reinterpret_cast< wxGrid * >(argp1);
12581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12582 if (!SWIG_IsOK(ecode2)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12584 }
12585 arg2 = static_cast< bool >(val2);
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (bool)(arg1)->MoveCursorUp(arg2);
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj = 0;
12603 wxGrid *arg1 = (wxGrid *) 0 ;
12604 bool arg2 ;
12605 bool result;
12606 void *argp1 = 0 ;
12607 int res1 = 0 ;
12608 bool val2 ;
12609 int ecode2 = 0 ;
12610 PyObject * obj0 = 0 ;
12611 PyObject * obj1 = 0 ;
12612 char * kwnames[] = {
12613 (char *) "self",(char *) "expandSelection", NULL
12614 };
12615
12616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12618 if (!SWIG_IsOK(res1)) {
12619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12620 }
12621 arg1 = reinterpret_cast< wxGrid * >(argp1);
12622 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12623 if (!SWIG_IsOK(ecode2)) {
12624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12625 }
12626 arg2 = static_cast< bool >(val2);
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 result = (bool)(arg1)->MoveCursorDown(arg2);
12630 wxPyEndAllowThreads(__tstate);
12631 if (PyErr_Occurred()) SWIG_fail;
12632 }
12633 {
12634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12635 }
12636 return resultobj;
12637 fail:
12638 return NULL;
12639 }
12640
12641
12642 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12643 PyObject *resultobj = 0;
12644 wxGrid *arg1 = (wxGrid *) 0 ;
12645 bool arg2 ;
12646 bool result;
12647 void *argp1 = 0 ;
12648 int res1 = 0 ;
12649 bool val2 ;
12650 int ecode2 = 0 ;
12651 PyObject * obj0 = 0 ;
12652 PyObject * obj1 = 0 ;
12653 char * kwnames[] = {
12654 (char *) "self",(char *) "expandSelection", NULL
12655 };
12656
12657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12659 if (!SWIG_IsOK(res1)) {
12660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12661 }
12662 arg1 = reinterpret_cast< wxGrid * >(argp1);
12663 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12664 if (!SWIG_IsOK(ecode2)) {
12665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12666 }
12667 arg2 = static_cast< bool >(val2);
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (bool)(arg1)->MoveCursorLeft(arg2);
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 {
12675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12676 }
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj = 0;
12685 wxGrid *arg1 = (wxGrid *) 0 ;
12686 bool arg2 ;
12687 bool result;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 bool val2 ;
12691 int ecode2 = 0 ;
12692 PyObject * obj0 = 0 ;
12693 PyObject * obj1 = 0 ;
12694 char * kwnames[] = {
12695 (char *) "self",(char *) "expandSelection", NULL
12696 };
12697
12698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12702 }
12703 arg1 = reinterpret_cast< wxGrid * >(argp1);
12704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12705 if (!SWIG_IsOK(ecode2)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12707 }
12708 arg2 = static_cast< bool >(val2);
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 result = (bool)(arg1)->MoveCursorRight(arg2);
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12717 }
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12725 PyObject *resultobj = 0;
12726 wxGrid *arg1 = (wxGrid *) 0 ;
12727 bool result;
12728 void *argp1 = 0 ;
12729 int res1 = 0 ;
12730 PyObject *swig_obj[1] ;
12731
12732 if (!args) SWIG_fail;
12733 swig_obj[0] = args;
12734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12735 if (!SWIG_IsOK(res1)) {
12736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12737 }
12738 arg1 = reinterpret_cast< wxGrid * >(argp1);
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (bool)(arg1)->MovePageDown();
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 {
12746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12747 }
12748 return resultobj;
12749 fail:
12750 return NULL;
12751 }
12752
12753
12754 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12755 PyObject *resultobj = 0;
12756 wxGrid *arg1 = (wxGrid *) 0 ;
12757 bool result;
12758 void *argp1 = 0 ;
12759 int res1 = 0 ;
12760 PyObject *swig_obj[1] ;
12761
12762 if (!args) SWIG_fail;
12763 swig_obj[0] = args;
12764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12765 if (!SWIG_IsOK(res1)) {
12766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12767 }
12768 arg1 = reinterpret_cast< wxGrid * >(argp1);
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 result = (bool)(arg1)->MovePageUp();
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 {
12776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12777 }
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj = 0;
12786 wxGrid *arg1 = (wxGrid *) 0 ;
12787 bool arg2 ;
12788 bool result;
12789 void *argp1 = 0 ;
12790 int res1 = 0 ;
12791 bool val2 ;
12792 int ecode2 = 0 ;
12793 PyObject * obj0 = 0 ;
12794 PyObject * obj1 = 0 ;
12795 char * kwnames[] = {
12796 (char *) "self",(char *) "expandSelection", NULL
12797 };
12798
12799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12803 }
12804 arg1 = reinterpret_cast< wxGrid * >(argp1);
12805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12806 if (!SWIG_IsOK(ecode2)) {
12807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12808 }
12809 arg2 = static_cast< bool >(val2);
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj = 0;
12827 wxGrid *arg1 = (wxGrid *) 0 ;
12828 bool arg2 ;
12829 bool result;
12830 void *argp1 = 0 ;
12831 int res1 = 0 ;
12832 bool val2 ;
12833 int ecode2 = 0 ;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 char * kwnames[] = {
12837 (char *) "self",(char *) "expandSelection", NULL
12838 };
12839
12840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12842 if (!SWIG_IsOK(res1)) {
12843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12844 }
12845 arg1 = reinterpret_cast< wxGrid * >(argp1);
12846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12847 if (!SWIG_IsOK(ecode2)) {
12848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12849 }
12850 arg2 = static_cast< bool >(val2);
12851 {
12852 PyThreadState* __tstate = wxPyBeginAllowThreads();
12853 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12854 wxPyEndAllowThreads(__tstate);
12855 if (PyErr_Occurred()) SWIG_fail;
12856 }
12857 {
12858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12859 }
12860 return resultobj;
12861 fail:
12862 return NULL;
12863 }
12864
12865
12866 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj = 0;
12868 wxGrid *arg1 = (wxGrid *) 0 ;
12869 bool arg2 ;
12870 bool result;
12871 void *argp1 = 0 ;
12872 int res1 = 0 ;
12873 bool val2 ;
12874 int ecode2 = 0 ;
12875 PyObject * obj0 = 0 ;
12876 PyObject * obj1 = 0 ;
12877 char * kwnames[] = {
12878 (char *) "self",(char *) "expandSelection", NULL
12879 };
12880
12881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12883 if (!SWIG_IsOK(res1)) {
12884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12885 }
12886 arg1 = reinterpret_cast< wxGrid * >(argp1);
12887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12888 if (!SWIG_IsOK(ecode2)) {
12889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12890 }
12891 arg2 = static_cast< bool >(val2);
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 {
12899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12900 }
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12908 PyObject *resultobj = 0;
12909 wxGrid *arg1 = (wxGrid *) 0 ;
12910 bool arg2 ;
12911 bool result;
12912 void *argp1 = 0 ;
12913 int res1 = 0 ;
12914 bool val2 ;
12915 int ecode2 = 0 ;
12916 PyObject * obj0 = 0 ;
12917 PyObject * obj1 = 0 ;
12918 char * kwnames[] = {
12919 (char *) "self",(char *) "expandSelection", NULL
12920 };
12921
12922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12926 }
12927 arg1 = reinterpret_cast< wxGrid * >(argp1);
12928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12931 }
12932 arg2 = static_cast< bool >(val2);
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 {
12940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12941 }
12942 return resultobj;
12943 fail:
12944 return NULL;
12945 }
12946
12947
12948 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12949 PyObject *resultobj = 0;
12950 wxGrid *arg1 = (wxGrid *) 0 ;
12951 int result;
12952 void *argp1 = 0 ;
12953 int res1 = 0 ;
12954 PyObject *swig_obj[1] ;
12955
12956 if (!args) SWIG_fail;
12957 swig_obj[0] = args;
12958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12959 if (!SWIG_IsOK(res1)) {
12960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12961 }
12962 arg1 = reinterpret_cast< wxGrid * >(argp1);
12963 {
12964 PyThreadState* __tstate = wxPyBeginAllowThreads();
12965 result = (int)(arg1)->GetDefaultRowLabelSize();
12966 wxPyEndAllowThreads(__tstate);
12967 if (PyErr_Occurred()) SWIG_fail;
12968 }
12969 resultobj = SWIG_From_int(static_cast< int >(result));
12970 return resultobj;
12971 fail:
12972 return NULL;
12973 }
12974
12975
12976 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12977 PyObject *resultobj = 0;
12978 wxGrid *arg1 = (wxGrid *) 0 ;
12979 int result;
12980 void *argp1 = 0 ;
12981 int res1 = 0 ;
12982 PyObject *swig_obj[1] ;
12983
12984 if (!args) SWIG_fail;
12985 swig_obj[0] = args;
12986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12989 }
12990 arg1 = reinterpret_cast< wxGrid * >(argp1);
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 result = (int)(arg1)->GetRowLabelSize();
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 resultobj = SWIG_From_int(static_cast< int >(result));
12998 return resultobj;
12999 fail:
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13005 PyObject *resultobj = 0;
13006 wxGrid *arg1 = (wxGrid *) 0 ;
13007 int result;
13008 void *argp1 = 0 ;
13009 int res1 = 0 ;
13010 PyObject *swig_obj[1] ;
13011
13012 if (!args) SWIG_fail;
13013 swig_obj[0] = args;
13014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13015 if (!SWIG_IsOK(res1)) {
13016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13017 }
13018 arg1 = reinterpret_cast< wxGrid * >(argp1);
13019 {
13020 PyThreadState* __tstate = wxPyBeginAllowThreads();
13021 result = (int)(arg1)->GetDefaultColLabelSize();
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 resultobj = SWIG_From_int(static_cast< int >(result));
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13033 PyObject *resultobj = 0;
13034 wxGrid *arg1 = (wxGrid *) 0 ;
13035 int result;
13036 void *argp1 = 0 ;
13037 int res1 = 0 ;
13038 PyObject *swig_obj[1] ;
13039
13040 if (!args) SWIG_fail;
13041 swig_obj[0] = args;
13042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13043 if (!SWIG_IsOK(res1)) {
13044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13045 }
13046 arg1 = reinterpret_cast< wxGrid * >(argp1);
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 result = (int)(arg1)->GetColLabelSize();
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 resultobj = SWIG_From_int(static_cast< int >(result));
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 wxGrid *arg1 = (wxGrid *) 0 ;
13063 wxColour result;
13064 void *argp1 = 0 ;
13065 int res1 = 0 ;
13066 PyObject *swig_obj[1] ;
13067
13068 if (!args) SWIG_fail;
13069 swig_obj[0] = args;
13070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13071 if (!SWIG_IsOK(res1)) {
13072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13073 }
13074 arg1 = reinterpret_cast< wxGrid * >(argp1);
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 result = (arg1)->GetLabelBackgroundColour();
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13082 return resultobj;
13083 fail:
13084 return NULL;
13085 }
13086
13087
13088 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13089 PyObject *resultobj = 0;
13090 wxGrid *arg1 = (wxGrid *) 0 ;
13091 wxColour result;
13092 void *argp1 = 0 ;
13093 int res1 = 0 ;
13094 PyObject *swig_obj[1] ;
13095
13096 if (!args) SWIG_fail;
13097 swig_obj[0] = args;
13098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13099 if (!SWIG_IsOK(res1)) {
13100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13101 }
13102 arg1 = reinterpret_cast< wxGrid * >(argp1);
13103 {
13104 PyThreadState* __tstate = wxPyBeginAllowThreads();
13105 result = (arg1)->GetLabelTextColour();
13106 wxPyEndAllowThreads(__tstate);
13107 if (PyErr_Occurred()) SWIG_fail;
13108 }
13109 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13110 return resultobj;
13111 fail:
13112 return NULL;
13113 }
13114
13115
13116 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13117 PyObject *resultobj = 0;
13118 wxGrid *arg1 = (wxGrid *) 0 ;
13119 wxFont result;
13120 void *argp1 = 0 ;
13121 int res1 = 0 ;
13122 PyObject *swig_obj[1] ;
13123
13124 if (!args) SWIG_fail;
13125 swig_obj[0] = args;
13126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13127 if (!SWIG_IsOK(res1)) {
13128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13129 }
13130 arg1 = reinterpret_cast< wxGrid * >(argp1);
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (arg1)->GetLabelFont();
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13145 PyObject *resultobj = 0;
13146 wxGrid *arg1 = (wxGrid *) 0 ;
13147 int *arg2 = (int *) 0 ;
13148 int *arg3 = (int *) 0 ;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 int temp2 ;
13152 int res2 = SWIG_TMPOBJ ;
13153 int temp3 ;
13154 int res3 = SWIG_TMPOBJ ;
13155 PyObject *swig_obj[1] ;
13156
13157 arg2 = &temp2;
13158 arg3 = &temp3;
13159 if (!args) SWIG_fail;
13160 swig_obj[0] = args;
13161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13162 if (!SWIG_IsOK(res1)) {
13163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13164 }
13165 arg1 = reinterpret_cast< wxGrid * >(argp1);
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 (arg1)->GetRowLabelAlignment(arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_Py_Void();
13173 if (SWIG_IsTmpObj(res2)) {
13174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13175 } else {
13176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13178 }
13179 if (SWIG_IsTmpObj(res3)) {
13180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13181 } else {
13182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13184 }
13185 return resultobj;
13186 fail:
13187 return NULL;
13188 }
13189
13190
13191 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13192 PyObject *resultobj = 0;
13193 wxGrid *arg1 = (wxGrid *) 0 ;
13194 int *arg2 = (int *) 0 ;
13195 int *arg3 = (int *) 0 ;
13196 void *argp1 = 0 ;
13197 int res1 = 0 ;
13198 int temp2 ;
13199 int res2 = SWIG_TMPOBJ ;
13200 int temp3 ;
13201 int res3 = SWIG_TMPOBJ ;
13202 PyObject *swig_obj[1] ;
13203
13204 arg2 = &temp2;
13205 arg3 = &temp3;
13206 if (!args) SWIG_fail;
13207 swig_obj[0] = args;
13208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13209 if (!SWIG_IsOK(res1)) {
13210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13211 }
13212 arg1 = reinterpret_cast< wxGrid * >(argp1);
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 (arg1)->GetColLabelAlignment(arg2,arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 resultobj = SWIG_Py_Void();
13220 if (SWIG_IsTmpObj(res2)) {
13221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13222 } else {
13223 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13225 }
13226 if (SWIG_IsTmpObj(res3)) {
13227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13228 } else {
13229 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13231 }
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13239 PyObject *resultobj = 0;
13240 wxGrid *arg1 = (wxGrid *) 0 ;
13241 int result;
13242 void *argp1 = 0 ;
13243 int res1 = 0 ;
13244 PyObject *swig_obj[1] ;
13245
13246 if (!args) SWIG_fail;
13247 swig_obj[0] = args;
13248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13249 if (!SWIG_IsOK(res1)) {
13250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13251 }
13252 arg1 = reinterpret_cast< wxGrid * >(argp1);
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 result = (int)(arg1)->GetColLabelTextOrientation();
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 resultobj = SWIG_From_int(static_cast< int >(result));
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxGrid *arg1 = (wxGrid *) 0 ;
13269 int arg2 ;
13270 wxString result;
13271 void *argp1 = 0 ;
13272 int res1 = 0 ;
13273 int val2 ;
13274 int ecode2 = 0 ;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 char * kwnames[] = {
13278 (char *) "self",(char *) "row", NULL
13279 };
13280
13281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13283 if (!SWIG_IsOK(res1)) {
13284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13285 }
13286 arg1 = reinterpret_cast< wxGrid * >(argp1);
13287 ecode2 = SWIG_AsVal_int(obj1, &val2);
13288 if (!SWIG_IsOK(ecode2)) {
13289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13290 }
13291 arg2 = static_cast< int >(val2);
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (arg1)->GetRowLabelValue(arg2);
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 {
13299 #if wxUSE_UNICODE
13300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13301 #else
13302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13303 #endif
13304 }
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj = 0;
13313 wxGrid *arg1 = (wxGrid *) 0 ;
13314 int arg2 ;
13315 wxString result;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 int val2 ;
13319 int ecode2 = 0 ;
13320 PyObject * obj0 = 0 ;
13321 PyObject * obj1 = 0 ;
13322 char * kwnames[] = {
13323 (char *) "self",(char *) "col", NULL
13324 };
13325
13326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13330 }
13331 arg1 = reinterpret_cast< wxGrid * >(argp1);
13332 ecode2 = SWIG_AsVal_int(obj1, &val2);
13333 if (!SWIG_IsOK(ecode2)) {
13334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13335 }
13336 arg2 = static_cast< int >(val2);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (arg1)->GetColLabelValue(arg2);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 {
13344 #if wxUSE_UNICODE
13345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13346 #else
13347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13348 #endif
13349 }
13350 return resultobj;
13351 fail:
13352 return NULL;
13353 }
13354
13355
13356 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13357 PyObject *resultobj = 0;
13358 wxGrid *arg1 = (wxGrid *) 0 ;
13359 wxColour result;
13360 void *argp1 = 0 ;
13361 int res1 = 0 ;
13362 PyObject *swig_obj[1] ;
13363
13364 if (!args) SWIG_fail;
13365 swig_obj[0] = args;
13366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13369 }
13370 arg1 = reinterpret_cast< wxGrid * >(argp1);
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (arg1)->GetGridLineColour();
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13378 return resultobj;
13379 fail:
13380 return NULL;
13381 }
13382
13383
13384 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13385 PyObject *resultobj = 0;
13386 wxGrid *arg1 = (wxGrid *) 0 ;
13387 wxPen result;
13388 void *argp1 = 0 ;
13389 int res1 = 0 ;
13390 PyObject *swig_obj[1] ;
13391
13392 if (!args) SWIG_fail;
13393 swig_obj[0] = args;
13394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13395 if (!SWIG_IsOK(res1)) {
13396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13397 }
13398 arg1 = reinterpret_cast< wxGrid * >(argp1);
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 result = (arg1)->GetDefaultGridLinePen();
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj = 0;
13414 wxGrid *arg1 = (wxGrid *) 0 ;
13415 int arg2 ;
13416 wxPen result;
13417 void *argp1 = 0 ;
13418 int res1 = 0 ;
13419 int val2 ;
13420 int ecode2 = 0 ;
13421 PyObject * obj0 = 0 ;
13422 PyObject * obj1 = 0 ;
13423 char * kwnames[] = {
13424 (char *) "self",(char *) "row", NULL
13425 };
13426
13427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13429 if (!SWIG_IsOK(res1)) {
13430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13431 }
13432 arg1 = reinterpret_cast< wxGrid * >(argp1);
13433 ecode2 = SWIG_AsVal_int(obj1, &val2);
13434 if (!SWIG_IsOK(ecode2)) {
13435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13436 }
13437 arg2 = static_cast< int >(val2);
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (arg1)->GetRowGridLinePen(arg2);
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13445 return resultobj;
13446 fail:
13447 return NULL;
13448 }
13449
13450
13451 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj = 0;
13453 wxGrid *arg1 = (wxGrid *) 0 ;
13454 int arg2 ;
13455 wxPen result;
13456 void *argp1 = 0 ;
13457 int res1 = 0 ;
13458 int val2 ;
13459 int ecode2 = 0 ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 char * kwnames[] = {
13463 (char *) "self",(char *) "col", NULL
13464 };
13465
13466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13470 }
13471 arg1 = reinterpret_cast< wxGrid * >(argp1);
13472 ecode2 = SWIG_AsVal_int(obj1, &val2);
13473 if (!SWIG_IsOK(ecode2)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13475 }
13476 arg2 = static_cast< int >(val2);
13477 {
13478 PyThreadState* __tstate = wxPyBeginAllowThreads();
13479 result = (arg1)->GetColGridLinePen(arg2);
13480 wxPyEndAllowThreads(__tstate);
13481 if (PyErr_Occurred()) SWIG_fail;
13482 }
13483 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13484 return resultobj;
13485 fail:
13486 return NULL;
13487 }
13488
13489
13490 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13491 PyObject *resultobj = 0;
13492 wxGrid *arg1 = (wxGrid *) 0 ;
13493 wxColour result;
13494 void *argp1 = 0 ;
13495 int res1 = 0 ;
13496 PyObject *swig_obj[1] ;
13497
13498 if (!args) SWIG_fail;
13499 swig_obj[0] = args;
13500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13501 if (!SWIG_IsOK(res1)) {
13502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13503 }
13504 arg1 = reinterpret_cast< wxGrid * >(argp1);
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 result = (arg1)->GetCellHighlightColour();
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13512 return resultobj;
13513 fail:
13514 return NULL;
13515 }
13516
13517
13518 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13519 PyObject *resultobj = 0;
13520 wxGrid *arg1 = (wxGrid *) 0 ;
13521 int result;
13522 void *argp1 = 0 ;
13523 int res1 = 0 ;
13524 PyObject *swig_obj[1] ;
13525
13526 if (!args) SWIG_fail;
13527 swig_obj[0] = args;
13528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13529 if (!SWIG_IsOK(res1)) {
13530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13531 }
13532 arg1 = reinterpret_cast< wxGrid * >(argp1);
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = (int)(arg1)->GetCellHighlightPenWidth();
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 resultobj = SWIG_From_int(static_cast< int >(result));
13540 return resultobj;
13541 fail:
13542 return NULL;
13543 }
13544
13545
13546 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13547 PyObject *resultobj = 0;
13548 wxGrid *arg1 = (wxGrid *) 0 ;
13549 int result;
13550 void *argp1 = 0 ;
13551 int res1 = 0 ;
13552 PyObject *swig_obj[1] ;
13553
13554 if (!args) SWIG_fail;
13555 swig_obj[0] = args;
13556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13557 if (!SWIG_IsOK(res1)) {
13558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13559 }
13560 arg1 = reinterpret_cast< wxGrid * >(argp1);
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (int)(arg1)->GetCellHighlightROPenWidth();
13564 wxPyEndAllowThreads(__tstate);
13565 if (PyErr_Occurred()) SWIG_fail;
13566 }
13567 resultobj = SWIG_From_int(static_cast< int >(result));
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = 0;
13576 wxGrid *arg1 = (wxGrid *) 0 ;
13577 int arg2 ;
13578 void *argp1 = 0 ;
13579 int res1 = 0 ;
13580 int val2 ;
13581 int ecode2 = 0 ;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "self",(char *) "width", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13590 if (!SWIG_IsOK(res1)) {
13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13592 }
13593 arg1 = reinterpret_cast< wxGrid * >(argp1);
13594 ecode2 = SWIG_AsVal_int(obj1, &val2);
13595 if (!SWIG_IsOK(ecode2)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13597 }
13598 arg2 = static_cast< int >(val2);
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 (arg1)->SetRowLabelSize(arg2);
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 resultobj = SWIG_Py_Void();
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj = 0;
13614 wxGrid *arg1 = (wxGrid *) 0 ;
13615 int arg2 ;
13616 void *argp1 = 0 ;
13617 int res1 = 0 ;
13618 int val2 ;
13619 int ecode2 = 0 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 char * kwnames[] = {
13623 (char *) "self",(char *) "height", NULL
13624 };
13625
13626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13628 if (!SWIG_IsOK(res1)) {
13629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13630 }
13631 arg1 = reinterpret_cast< wxGrid * >(argp1);
13632 ecode2 = SWIG_AsVal_int(obj1, &val2);
13633 if (!SWIG_IsOK(ecode2)) {
13634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13635 }
13636 arg2 = static_cast< int >(val2);
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 (arg1)->SetColLabelSize(arg2);
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_Py_Void();
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj = 0;
13652 wxGrid *arg1 = (wxGrid *) 0 ;
13653 wxColour *arg2 = 0 ;
13654 void *argp1 = 0 ;
13655 int res1 = 0 ;
13656 wxColour temp2 ;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 char * kwnames[] = {
13660 (char *) "self",(char *)"arg2", NULL
13661 };
13662
13663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13665 if (!SWIG_IsOK(res1)) {
13666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13667 }
13668 arg1 = reinterpret_cast< wxGrid * >(argp1);
13669 {
13670 arg2 = &temp2;
13671 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13672 }
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13676 wxPyEndAllowThreads(__tstate);
13677 if (PyErr_Occurred()) SWIG_fail;
13678 }
13679 resultobj = SWIG_Py_Void();
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj = 0;
13688 wxGrid *arg1 = (wxGrid *) 0 ;
13689 wxColour *arg2 = 0 ;
13690 void *argp1 = 0 ;
13691 int res1 = 0 ;
13692 wxColour temp2 ;
13693 PyObject * obj0 = 0 ;
13694 PyObject * obj1 = 0 ;
13695 char * kwnames[] = {
13696 (char *) "self",(char *)"arg2", NULL
13697 };
13698
13699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13701 if (!SWIG_IsOK(res1)) {
13702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13703 }
13704 arg1 = reinterpret_cast< wxGrid * >(argp1);
13705 {
13706 arg2 = &temp2;
13707 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13708 }
13709 {
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13712 wxPyEndAllowThreads(__tstate);
13713 if (PyErr_Occurred()) SWIG_fail;
13714 }
13715 resultobj = SWIG_Py_Void();
13716 return resultobj;
13717 fail:
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj = 0;
13724 wxGrid *arg1 = (wxGrid *) 0 ;
13725 wxFont *arg2 = 0 ;
13726 void *argp1 = 0 ;
13727 int res1 = 0 ;
13728 void *argp2 = 0 ;
13729 int res2 = 0 ;
13730 PyObject * obj0 = 0 ;
13731 PyObject * obj1 = 0 ;
13732 char * kwnames[] = {
13733 (char *) "self",(char *)"arg2", NULL
13734 };
13735
13736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13738 if (!SWIG_IsOK(res1)) {
13739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13740 }
13741 arg1 = reinterpret_cast< wxGrid * >(argp1);
13742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13743 if (!SWIG_IsOK(res2)) {
13744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13745 }
13746 if (!argp2) {
13747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13748 }
13749 arg2 = reinterpret_cast< wxFont * >(argp2);
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 (arg1)->SetLabelFont((wxFont const &)*arg2);
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_Py_Void();
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxGrid *arg1 = (wxGrid *) 0 ;
13766 int arg2 ;
13767 int arg3 ;
13768 void *argp1 = 0 ;
13769 int res1 = 0 ;
13770 int val2 ;
13771 int ecode2 = 0 ;
13772 int val3 ;
13773 int ecode3 = 0 ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 char * kwnames[] = {
13778 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13779 };
13780
13781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13783 if (!SWIG_IsOK(res1)) {
13784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13785 }
13786 arg1 = reinterpret_cast< wxGrid * >(argp1);
13787 ecode2 = SWIG_AsVal_int(obj1, &val2);
13788 if (!SWIG_IsOK(ecode2)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13790 }
13791 arg2 = static_cast< int >(val2);
13792 ecode3 = SWIG_AsVal_int(obj2, &val3);
13793 if (!SWIG_IsOK(ecode3)) {
13794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13795 }
13796 arg3 = static_cast< int >(val3);
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 (arg1)->SetRowLabelAlignment(arg2,arg3);
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_Py_Void();
13804 return resultobj;
13805 fail:
13806 return NULL;
13807 }
13808
13809
13810 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13811 PyObject *resultobj = 0;
13812 wxGrid *arg1 = (wxGrid *) 0 ;
13813 int arg2 ;
13814 int arg3 ;
13815 void *argp1 = 0 ;
13816 int res1 = 0 ;
13817 int val2 ;
13818 int ecode2 = 0 ;
13819 int val3 ;
13820 int ecode3 = 0 ;
13821 PyObject * obj0 = 0 ;
13822 PyObject * obj1 = 0 ;
13823 PyObject * obj2 = 0 ;
13824 char * kwnames[] = {
13825 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13826 };
13827
13828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13830 if (!SWIG_IsOK(res1)) {
13831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13832 }
13833 arg1 = reinterpret_cast< wxGrid * >(argp1);
13834 ecode2 = SWIG_AsVal_int(obj1, &val2);
13835 if (!SWIG_IsOK(ecode2)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13837 }
13838 arg2 = static_cast< int >(val2);
13839 ecode3 = SWIG_AsVal_int(obj2, &val3);
13840 if (!SWIG_IsOK(ecode3)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13842 }
13843 arg3 = static_cast< int >(val3);
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 (arg1)->SetColLabelAlignment(arg2,arg3);
13847 wxPyEndAllowThreads(__tstate);
13848 if (PyErr_Occurred()) SWIG_fail;
13849 }
13850 resultobj = SWIG_Py_Void();
13851 return resultobj;
13852 fail:
13853 return NULL;
13854 }
13855
13856
13857 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj = 0;
13859 wxGrid *arg1 = (wxGrid *) 0 ;
13860 int arg2 ;
13861 void *argp1 = 0 ;
13862 int res1 = 0 ;
13863 int val2 ;
13864 int ecode2 = 0 ;
13865 PyObject * obj0 = 0 ;
13866 PyObject * obj1 = 0 ;
13867 char * kwnames[] = {
13868 (char *) "self",(char *) "textOrientation", NULL
13869 };
13870
13871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13873 if (!SWIG_IsOK(res1)) {
13874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13875 }
13876 arg1 = reinterpret_cast< wxGrid * >(argp1);
13877 ecode2 = SWIG_AsVal_int(obj1, &val2);
13878 if (!SWIG_IsOK(ecode2)) {
13879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13880 }
13881 arg2 = static_cast< int >(val2);
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 (arg1)->SetColLabelTextOrientation(arg2);
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 resultobj = SWIG_Py_Void();
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13896 PyObject *resultobj = 0;
13897 wxGrid *arg1 = (wxGrid *) 0 ;
13898 int arg2 ;
13899 wxString *arg3 = 0 ;
13900 void *argp1 = 0 ;
13901 int res1 = 0 ;
13902 int val2 ;
13903 int ecode2 = 0 ;
13904 bool temp3 = false ;
13905 PyObject * obj0 = 0 ;
13906 PyObject * obj1 = 0 ;
13907 PyObject * obj2 = 0 ;
13908 char * kwnames[] = {
13909 (char *) "self",(char *) "row",(char *)"arg3", NULL
13910 };
13911
13912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13914 if (!SWIG_IsOK(res1)) {
13915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13916 }
13917 arg1 = reinterpret_cast< wxGrid * >(argp1);
13918 ecode2 = SWIG_AsVal_int(obj1, &val2);
13919 if (!SWIG_IsOK(ecode2)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13921 }
13922 arg2 = static_cast< int >(val2);
13923 {
13924 arg3 = wxString_in_helper(obj2);
13925 if (arg3 == NULL) SWIG_fail;
13926 temp3 = true;
13927 }
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_Py_Void();
13935 {
13936 if (temp3)
13937 delete arg3;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp3)
13943 delete arg3;
13944 }
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxGrid *arg1 = (wxGrid *) 0 ;
13952 int arg2 ;
13953 wxString *arg3 = 0 ;
13954 void *argp1 = 0 ;
13955 int res1 = 0 ;
13956 int val2 ;
13957 int ecode2 = 0 ;
13958 bool temp3 = false ;
13959 PyObject * obj0 = 0 ;
13960 PyObject * obj1 = 0 ;
13961 PyObject * obj2 = 0 ;
13962 char * kwnames[] = {
13963 (char *) "self",(char *) "col",(char *)"arg3", NULL
13964 };
13965
13966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13968 if (!SWIG_IsOK(res1)) {
13969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13970 }
13971 arg1 = reinterpret_cast< wxGrid * >(argp1);
13972 ecode2 = SWIG_AsVal_int(obj1, &val2);
13973 if (!SWIG_IsOK(ecode2)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13975 }
13976 arg2 = static_cast< int >(val2);
13977 {
13978 arg3 = wxString_in_helper(obj2);
13979 if (arg3 == NULL) SWIG_fail;
13980 temp3 = true;
13981 }
13982 {
13983 PyThreadState* __tstate = wxPyBeginAllowThreads();
13984 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 resultobj = SWIG_Py_Void();
13989 {
13990 if (temp3)
13991 delete arg3;
13992 }
13993 return resultobj;
13994 fail:
13995 {
13996 if (temp3)
13997 delete arg3;
13998 }
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj = 0;
14005 wxGrid *arg1 = (wxGrid *) 0 ;
14006 wxColour *arg2 = 0 ;
14007 void *argp1 = 0 ;
14008 int res1 = 0 ;
14009 wxColour temp2 ;
14010 PyObject * obj0 = 0 ;
14011 PyObject * obj1 = 0 ;
14012 char * kwnames[] = {
14013 (char *) "self",(char *)"arg2", NULL
14014 };
14015
14016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14020 }
14021 arg1 = reinterpret_cast< wxGrid * >(argp1);
14022 {
14023 arg2 = &temp2;
14024 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14025 }
14026 {
14027 PyThreadState* __tstate = wxPyBeginAllowThreads();
14028 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 resultobj = SWIG_Py_Void();
14033 return resultobj;
14034 fail:
14035 return NULL;
14036 }
14037
14038
14039 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14040 PyObject *resultobj = 0;
14041 wxGrid *arg1 = (wxGrid *) 0 ;
14042 wxColour *arg2 = 0 ;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 wxColour temp2 ;
14046 PyObject * obj0 = 0 ;
14047 PyObject * obj1 = 0 ;
14048 char * kwnames[] = {
14049 (char *) "self",(char *)"arg2", NULL
14050 };
14051
14052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14054 if (!SWIG_IsOK(res1)) {
14055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14056 }
14057 arg1 = reinterpret_cast< wxGrid * >(argp1);
14058 {
14059 arg2 = &temp2;
14060 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14061 }
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 resultobj = SWIG_Py_Void();
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14076 PyObject *resultobj = 0;
14077 wxGrid *arg1 = (wxGrid *) 0 ;
14078 int arg2 ;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 int val2 ;
14082 int ecode2 = 0 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 char * kwnames[] = {
14086 (char *) "self",(char *) "width", NULL
14087 };
14088
14089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14091 if (!SWIG_IsOK(res1)) {
14092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14093 }
14094 arg1 = reinterpret_cast< wxGrid * >(argp1);
14095 ecode2 = SWIG_AsVal_int(obj1, &val2);
14096 if (!SWIG_IsOK(ecode2)) {
14097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14098 }
14099 arg2 = static_cast< int >(val2);
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 (arg1)->SetCellHighlightPenWidth(arg2);
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 resultobj = SWIG_Py_Void();
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj = 0;
14115 wxGrid *arg1 = (wxGrid *) 0 ;
14116 int arg2 ;
14117 void *argp1 = 0 ;
14118 int res1 = 0 ;
14119 int val2 ;
14120 int ecode2 = 0 ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 char * kwnames[] = {
14124 (char *) "self",(char *) "width", NULL
14125 };
14126
14127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14131 }
14132 arg1 = reinterpret_cast< wxGrid * >(argp1);
14133 ecode2 = SWIG_AsVal_int(obj1, &val2);
14134 if (!SWIG_IsOK(ecode2)) {
14135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14136 }
14137 arg2 = static_cast< int >(val2);
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 (arg1)->SetCellHighlightROPenWidth(arg2);
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 resultobj = SWIG_Py_Void();
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14152 PyObject *resultobj = 0;
14153 wxGrid *arg1 = (wxGrid *) 0 ;
14154 bool arg2 = (bool) true ;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 bool val2 ;
14158 int ecode2 = 0 ;
14159 PyObject * obj0 = 0 ;
14160 PyObject * obj1 = 0 ;
14161 char * kwnames[] = {
14162 (char *) "self",(char *) "enable", NULL
14163 };
14164
14165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14167 if (!SWIG_IsOK(res1)) {
14168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14169 }
14170 arg1 = reinterpret_cast< wxGrid * >(argp1);
14171 if (obj1) {
14172 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14173 if (!SWIG_IsOK(ecode2)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14175 }
14176 arg2 = static_cast< bool >(val2);
14177 }
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 (arg1)->EnableDragRowSize(arg2);
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 resultobj = SWIG_Py_Void();
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14192 PyObject *resultobj = 0;
14193 wxGrid *arg1 = (wxGrid *) 0 ;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 PyObject *swig_obj[1] ;
14197
14198 if (!args) SWIG_fail;
14199 swig_obj[0] = args;
14200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14201 if (!SWIG_IsOK(res1)) {
14202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14203 }
14204 arg1 = reinterpret_cast< wxGrid * >(argp1);
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 (arg1)->DisableDragRowSize();
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_Py_Void();
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14219 PyObject *resultobj = 0;
14220 wxGrid *arg1 = (wxGrid *) 0 ;
14221 bool result;
14222 void *argp1 = 0 ;
14223 int res1 = 0 ;
14224 PyObject *swig_obj[1] ;
14225
14226 if (!args) SWIG_fail;
14227 swig_obj[0] = args;
14228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14231 }
14232 arg1 = reinterpret_cast< wxGrid * >(argp1);
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (bool)(arg1)->CanDragRowSize();
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 {
14240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14241 }
14242 return resultobj;
14243 fail:
14244 return NULL;
14245 }
14246
14247
14248 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14249 PyObject *resultobj = 0;
14250 wxGrid *arg1 = (wxGrid *) 0 ;
14251 bool arg2 = (bool) true ;
14252 void *argp1 = 0 ;
14253 int res1 = 0 ;
14254 bool val2 ;
14255 int ecode2 = 0 ;
14256 PyObject * obj0 = 0 ;
14257 PyObject * obj1 = 0 ;
14258 char * kwnames[] = {
14259 (char *) "self",(char *) "enable", NULL
14260 };
14261
14262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14264 if (!SWIG_IsOK(res1)) {
14265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14266 }
14267 arg1 = reinterpret_cast< wxGrid * >(argp1);
14268 if (obj1) {
14269 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14270 if (!SWIG_IsOK(ecode2)) {
14271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14272 }
14273 arg2 = static_cast< bool >(val2);
14274 }
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 (arg1)->EnableDragColSize(arg2);
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 resultobj = SWIG_Py_Void();
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14289 PyObject *resultobj = 0;
14290 wxGrid *arg1 = (wxGrid *) 0 ;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 PyObject *swig_obj[1] ;
14294
14295 if (!args) SWIG_fail;
14296 swig_obj[0] = args;
14297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14300 }
14301 arg1 = reinterpret_cast< wxGrid * >(argp1);
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 (arg1)->DisableDragColSize();
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 resultobj = SWIG_Py_Void();
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14316 PyObject *resultobj = 0;
14317 wxGrid *arg1 = (wxGrid *) 0 ;
14318 bool result;
14319 void *argp1 = 0 ;
14320 int res1 = 0 ;
14321 PyObject *swig_obj[1] ;
14322
14323 if (!args) SWIG_fail;
14324 swig_obj[0] = args;
14325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14326 if (!SWIG_IsOK(res1)) {
14327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14328 }
14329 arg1 = reinterpret_cast< wxGrid * >(argp1);
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (bool)(arg1)->CanDragColSize();
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 {
14337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14338 }
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxGrid *arg1 = (wxGrid *) 0 ;
14348 bool arg2 = (bool) true ;
14349 void *argp1 = 0 ;
14350 int res1 = 0 ;
14351 bool val2 ;
14352 int ecode2 = 0 ;
14353 PyObject * obj0 = 0 ;
14354 PyObject * obj1 = 0 ;
14355 char * kwnames[] = {
14356 (char *) "self",(char *) "enable", NULL
14357 };
14358
14359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14363 }
14364 arg1 = reinterpret_cast< wxGrid * >(argp1);
14365 if (obj1) {
14366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14367 if (!SWIG_IsOK(ecode2)) {
14368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14369 }
14370 arg2 = static_cast< bool >(val2);
14371 }
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 (arg1)->EnableDragColMove(arg2);
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 resultobj = SWIG_Py_Void();
14379 return resultobj;
14380 fail:
14381 return NULL;
14382 }
14383
14384
14385 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14386 PyObject *resultobj = 0;
14387 wxGrid *arg1 = (wxGrid *) 0 ;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 PyObject *swig_obj[1] ;
14391
14392 if (!args) SWIG_fail;
14393 swig_obj[0] = args;
14394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14395 if (!SWIG_IsOK(res1)) {
14396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14397 }
14398 arg1 = reinterpret_cast< wxGrid * >(argp1);
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 (arg1)->DisableDragColMove();
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 resultobj = SWIG_Py_Void();
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14413 PyObject *resultobj = 0;
14414 wxGrid *arg1 = (wxGrid *) 0 ;
14415 bool result;
14416 void *argp1 = 0 ;
14417 int res1 = 0 ;
14418 PyObject *swig_obj[1] ;
14419
14420 if (!args) SWIG_fail;
14421 swig_obj[0] = args;
14422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14423 if (!SWIG_IsOK(res1)) {
14424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14425 }
14426 arg1 = reinterpret_cast< wxGrid * >(argp1);
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (bool)(arg1)->CanDragColMove();
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 {
14434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj = 0;
14444 wxGrid *arg1 = (wxGrid *) 0 ;
14445 bool arg2 = (bool) true ;
14446 void *argp1 = 0 ;
14447 int res1 = 0 ;
14448 bool val2 ;
14449 int ecode2 = 0 ;
14450 PyObject * obj0 = 0 ;
14451 PyObject * obj1 = 0 ;
14452 char * kwnames[] = {
14453 (char *) "self",(char *) "enable", NULL
14454 };
14455
14456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14458 if (!SWIG_IsOK(res1)) {
14459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14460 }
14461 arg1 = reinterpret_cast< wxGrid * >(argp1);
14462 if (obj1) {
14463 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14464 if (!SWIG_IsOK(ecode2)) {
14465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14466 }
14467 arg2 = static_cast< bool >(val2);
14468 }
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 (arg1)->EnableDragGridSize(arg2);
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_Py_Void();
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483 PyObject *resultobj = 0;
14484 wxGrid *arg1 = (wxGrid *) 0 ;
14485 void *argp1 = 0 ;
14486 int res1 = 0 ;
14487 PyObject *swig_obj[1] ;
14488
14489 if (!args) SWIG_fail;
14490 swig_obj[0] = args;
14491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14494 }
14495 arg1 = reinterpret_cast< wxGrid * >(argp1);
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 (arg1)->DisableDragGridSize();
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_Py_Void();
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14510 PyObject *resultobj = 0;
14511 wxGrid *arg1 = (wxGrid *) 0 ;
14512 bool result;
14513 void *argp1 = 0 ;
14514 int res1 = 0 ;
14515 PyObject *swig_obj[1] ;
14516
14517 if (!args) SWIG_fail;
14518 swig_obj[0] = args;
14519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14520 if (!SWIG_IsOK(res1)) {
14521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14522 }
14523 arg1 = reinterpret_cast< wxGrid * >(argp1);
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)(arg1)->CanDragGridSize();
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 {
14531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14532 }
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14540 PyObject *resultobj = 0;
14541 wxGrid *arg1 = (wxGrid *) 0 ;
14542 bool arg2 = (bool) true ;
14543 void *argp1 = 0 ;
14544 int res1 = 0 ;
14545 bool val2 ;
14546 int ecode2 = 0 ;
14547 PyObject * obj0 = 0 ;
14548 PyObject * obj1 = 0 ;
14549 char * kwnames[] = {
14550 (char *) "self",(char *) "enable", NULL
14551 };
14552
14553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14555 if (!SWIG_IsOK(res1)) {
14556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14557 }
14558 arg1 = reinterpret_cast< wxGrid * >(argp1);
14559 if (obj1) {
14560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14561 if (!SWIG_IsOK(ecode2)) {
14562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14563 }
14564 arg2 = static_cast< bool >(val2);
14565 }
14566 {
14567 PyThreadState* __tstate = wxPyBeginAllowThreads();
14568 (arg1)->EnableDragCell(arg2);
14569 wxPyEndAllowThreads(__tstate);
14570 if (PyErr_Occurred()) SWIG_fail;
14571 }
14572 resultobj = SWIG_Py_Void();
14573 return resultobj;
14574 fail:
14575 return NULL;
14576 }
14577
14578
14579 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14580 PyObject *resultobj = 0;
14581 wxGrid *arg1 = (wxGrid *) 0 ;
14582 void *argp1 = 0 ;
14583 int res1 = 0 ;
14584 PyObject *swig_obj[1] ;
14585
14586 if (!args) SWIG_fail;
14587 swig_obj[0] = args;
14588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14589 if (!SWIG_IsOK(res1)) {
14590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14591 }
14592 arg1 = reinterpret_cast< wxGrid * >(argp1);
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 (arg1)->DisableDragCell();
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 resultobj = SWIG_Py_Void();
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14607 PyObject *resultobj = 0;
14608 wxGrid *arg1 = (wxGrid *) 0 ;
14609 bool result;
14610 void *argp1 = 0 ;
14611 int res1 = 0 ;
14612 PyObject *swig_obj[1] ;
14613
14614 if (!args) SWIG_fail;
14615 swig_obj[0] = args;
14616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14619 }
14620 arg1 = reinterpret_cast< wxGrid * >(argp1);
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 result = (bool)(arg1)->CanDragCell();
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 {
14628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14629 }
14630 return resultobj;
14631 fail:
14632 return NULL;
14633 }
14634
14635
14636 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14637 PyObject *resultobj = 0;
14638 wxGrid *arg1 = (wxGrid *) 0 ;
14639 int arg2 ;
14640 int arg3 ;
14641 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14642 void *argp1 = 0 ;
14643 int res1 = 0 ;
14644 int val2 ;
14645 int ecode2 = 0 ;
14646 int val3 ;
14647 int ecode3 = 0 ;
14648 void *argp4 = 0 ;
14649 int res4 = 0 ;
14650 PyObject * obj0 = 0 ;
14651 PyObject * obj1 = 0 ;
14652 PyObject * obj2 = 0 ;
14653 PyObject * obj3 = 0 ;
14654 char * kwnames[] = {
14655 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14656 };
14657
14658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14662 }
14663 arg1 = reinterpret_cast< wxGrid * >(argp1);
14664 ecode2 = SWIG_AsVal_int(obj1, &val2);
14665 if (!SWIG_IsOK(ecode2)) {
14666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14667 }
14668 arg2 = static_cast< int >(val2);
14669 ecode3 = SWIG_AsVal_int(obj2, &val3);
14670 if (!SWIG_IsOK(ecode3)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14672 }
14673 arg3 = static_cast< int >(val3);
14674 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14675 if (!SWIG_IsOK(res4)) {
14676 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14677 }
14678 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 (arg1)->SetAttr(arg2,arg3,arg4);
14682 wxPyEndAllowThreads(__tstate);
14683 if (PyErr_Occurred()) SWIG_fail;
14684 }
14685 resultobj = SWIG_Py_Void();
14686 return resultobj;
14687 fail:
14688 return NULL;
14689 }
14690
14691
14692 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj = 0;
14694 wxGrid *arg1 = (wxGrid *) 0 ;
14695 int arg2 ;
14696 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14697 void *argp1 = 0 ;
14698 int res1 = 0 ;
14699 int val2 ;
14700 int ecode2 = 0 ;
14701 void *argp3 = 0 ;
14702 int res3 = 0 ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 PyObject * obj2 = 0 ;
14706 char * kwnames[] = {
14707 (char *) "self",(char *) "row",(char *) "attr", NULL
14708 };
14709
14710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14714 }
14715 arg1 = reinterpret_cast< wxGrid * >(argp1);
14716 ecode2 = SWIG_AsVal_int(obj1, &val2);
14717 if (!SWIG_IsOK(ecode2)) {
14718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14719 }
14720 arg2 = static_cast< int >(val2);
14721 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14722 if (!SWIG_IsOK(res3)) {
14723 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14724 }
14725 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 (arg1)->SetRowAttr(arg2,arg3);
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 resultobj = SWIG_Py_Void();
14733 return resultobj;
14734 fail:
14735 return NULL;
14736 }
14737
14738
14739 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14740 PyObject *resultobj = 0;
14741 wxGrid *arg1 = (wxGrid *) 0 ;
14742 int arg2 ;
14743 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14744 void *argp1 = 0 ;
14745 int res1 = 0 ;
14746 int val2 ;
14747 int ecode2 = 0 ;
14748 void *argp3 = 0 ;
14749 int res3 = 0 ;
14750 PyObject * obj0 = 0 ;
14751 PyObject * obj1 = 0 ;
14752 PyObject * obj2 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "col",(char *) "attr", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14761 }
14762 arg1 = reinterpret_cast< wxGrid * >(argp1);
14763 ecode2 = SWIG_AsVal_int(obj1, &val2);
14764 if (!SWIG_IsOK(ecode2)) {
14765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14766 }
14767 arg2 = static_cast< int >(val2);
14768 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14769 if (!SWIG_IsOK(res3)) {
14770 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14771 }
14772 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 (arg1)->SetColAttr(arg2,arg3);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 resultobj = SWIG_Py_Void();
14780 return resultobj;
14781 fail:
14782 return NULL;
14783 }
14784
14785
14786 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14787 PyObject *resultobj = 0;
14788 wxGrid *arg1 = (wxGrid *) 0 ;
14789 int arg2 ;
14790 int arg3 ;
14791 wxGridCellAttr *result = 0 ;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 int val2 ;
14795 int ecode2 = 0 ;
14796 int val3 ;
14797 int ecode3 = 0 ;
14798 PyObject * obj0 = 0 ;
14799 PyObject * obj1 = 0 ;
14800 PyObject * obj2 = 0 ;
14801 char * kwnames[] = {
14802 (char *) "self",(char *) "row",(char *) "col", NULL
14803 };
14804
14805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14809 }
14810 arg1 = reinterpret_cast< wxGrid * >(argp1);
14811 ecode2 = SWIG_AsVal_int(obj1, &val2);
14812 if (!SWIG_IsOK(ecode2)) {
14813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14814 }
14815 arg2 = static_cast< int >(val2);
14816 ecode3 = SWIG_AsVal_int(obj2, &val3);
14817 if (!SWIG_IsOK(ecode3)) {
14818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14819 }
14820 arg3 = static_cast< int >(val3);
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 {
14828 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14829 }
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj = 0;
14838 wxGrid *arg1 = (wxGrid *) 0 ;
14839 int arg2 ;
14840 void *argp1 = 0 ;
14841 int res1 = 0 ;
14842 int val2 ;
14843 int ecode2 = 0 ;
14844 PyObject * obj0 = 0 ;
14845 PyObject * obj1 = 0 ;
14846 char * kwnames[] = {
14847 (char *) "self",(char *) "col", NULL
14848 };
14849
14850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14852 if (!SWIG_IsOK(res1)) {
14853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14854 }
14855 arg1 = reinterpret_cast< wxGrid * >(argp1);
14856 ecode2 = SWIG_AsVal_int(obj1, &val2);
14857 if (!SWIG_IsOK(ecode2)) {
14858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14859 }
14860 arg2 = static_cast< int >(val2);
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 (arg1)->SetColFormatBool(arg2);
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 resultobj = SWIG_Py_Void();
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14875 PyObject *resultobj = 0;
14876 wxGrid *arg1 = (wxGrid *) 0 ;
14877 int arg2 ;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 int val2 ;
14881 int ecode2 = 0 ;
14882 PyObject * obj0 = 0 ;
14883 PyObject * obj1 = 0 ;
14884 char * kwnames[] = {
14885 (char *) "self",(char *) "col", NULL
14886 };
14887
14888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14890 if (!SWIG_IsOK(res1)) {
14891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14892 }
14893 arg1 = reinterpret_cast< wxGrid * >(argp1);
14894 ecode2 = SWIG_AsVal_int(obj1, &val2);
14895 if (!SWIG_IsOK(ecode2)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14897 }
14898 arg2 = static_cast< int >(val2);
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 (arg1)->SetColFormatNumber(arg2);
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 resultobj = SWIG_Py_Void();
14906 return resultobj;
14907 fail:
14908 return NULL;
14909 }
14910
14911
14912 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14913 PyObject *resultobj = 0;
14914 wxGrid *arg1 = (wxGrid *) 0 ;
14915 int arg2 ;
14916 int arg3 = (int) -1 ;
14917 int arg4 = (int) -1 ;
14918 void *argp1 = 0 ;
14919 int res1 = 0 ;
14920 int val2 ;
14921 int ecode2 = 0 ;
14922 int val3 ;
14923 int ecode3 = 0 ;
14924 int val4 ;
14925 int ecode4 = 0 ;
14926 PyObject * obj0 = 0 ;
14927 PyObject * obj1 = 0 ;
14928 PyObject * obj2 = 0 ;
14929 PyObject * obj3 = 0 ;
14930 char * kwnames[] = {
14931 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14932 };
14933
14934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14936 if (!SWIG_IsOK(res1)) {
14937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14938 }
14939 arg1 = reinterpret_cast< wxGrid * >(argp1);
14940 ecode2 = SWIG_AsVal_int(obj1, &val2);
14941 if (!SWIG_IsOK(ecode2)) {
14942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14943 }
14944 arg2 = static_cast< int >(val2);
14945 if (obj2) {
14946 ecode3 = SWIG_AsVal_int(obj2, &val3);
14947 if (!SWIG_IsOK(ecode3)) {
14948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14949 }
14950 arg3 = static_cast< int >(val3);
14951 }
14952 if (obj3) {
14953 ecode4 = SWIG_AsVal_int(obj3, &val4);
14954 if (!SWIG_IsOK(ecode4)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14956 }
14957 arg4 = static_cast< int >(val4);
14958 }
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 resultobj = SWIG_Py_Void();
14966 return resultobj;
14967 fail:
14968 return NULL;
14969 }
14970
14971
14972 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj = 0;
14974 wxGrid *arg1 = (wxGrid *) 0 ;
14975 int arg2 ;
14976 wxString *arg3 = 0 ;
14977 void *argp1 = 0 ;
14978 int res1 = 0 ;
14979 int val2 ;
14980 int ecode2 = 0 ;
14981 bool temp3 = false ;
14982 PyObject * obj0 = 0 ;
14983 PyObject * obj1 = 0 ;
14984 PyObject * obj2 = 0 ;
14985 char * kwnames[] = {
14986 (char *) "self",(char *) "col",(char *) "typeName", NULL
14987 };
14988
14989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14991 if (!SWIG_IsOK(res1)) {
14992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14993 }
14994 arg1 = reinterpret_cast< wxGrid * >(argp1);
14995 ecode2 = SWIG_AsVal_int(obj1, &val2);
14996 if (!SWIG_IsOK(ecode2)) {
14997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14998 }
14999 arg2 = static_cast< int >(val2);
15000 {
15001 arg3 = wxString_in_helper(obj2);
15002 if (arg3 == NULL) SWIG_fail;
15003 temp3 = true;
15004 }
15005 {
15006 PyThreadState* __tstate = wxPyBeginAllowThreads();
15007 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 resultobj = SWIG_Py_Void();
15012 {
15013 if (temp3)
15014 delete arg3;
15015 }
15016 return resultobj;
15017 fail:
15018 {
15019 if (temp3)
15020 delete arg3;
15021 }
15022 return NULL;
15023 }
15024
15025
15026 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15027 PyObject *resultobj = 0;
15028 wxGrid *arg1 = (wxGrid *) 0 ;
15029 bool arg2 = (bool) true ;
15030 void *argp1 = 0 ;
15031 int res1 = 0 ;
15032 bool val2 ;
15033 int ecode2 = 0 ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 char * kwnames[] = {
15037 (char *) "self",(char *) "enable", NULL
15038 };
15039
15040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15042 if (!SWIG_IsOK(res1)) {
15043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15044 }
15045 arg1 = reinterpret_cast< wxGrid * >(argp1);
15046 if (obj1) {
15047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15048 if (!SWIG_IsOK(ecode2)) {
15049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15050 }
15051 arg2 = static_cast< bool >(val2);
15052 }
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 (arg1)->EnableGridLines(arg2);
15056 wxPyEndAllowThreads(__tstate);
15057 if (PyErr_Occurred()) SWIG_fail;
15058 }
15059 resultobj = SWIG_Py_Void();
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15067 PyObject *resultobj = 0;
15068 wxGrid *arg1 = (wxGrid *) 0 ;
15069 bool result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 PyObject *swig_obj[1] ;
15073
15074 if (!args) SWIG_fail;
15075 swig_obj[0] = args;
15076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15079 }
15080 arg1 = reinterpret_cast< wxGrid * >(argp1);
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (bool)(arg1)->GridLinesEnabled();
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 {
15088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15089 }
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15097 PyObject *resultobj = 0;
15098 wxGrid *arg1 = (wxGrid *) 0 ;
15099 int result;
15100 void *argp1 = 0 ;
15101 int res1 = 0 ;
15102 PyObject *swig_obj[1] ;
15103
15104 if (!args) SWIG_fail;
15105 swig_obj[0] = args;
15106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15107 if (!SWIG_IsOK(res1)) {
15108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15109 }
15110 arg1 = reinterpret_cast< wxGrid * >(argp1);
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (int)(arg1)->GetDefaultRowSize();
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 resultobj = SWIG_From_int(static_cast< int >(result));
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 wxGrid *arg1 = (wxGrid *) 0 ;
15127 int arg2 ;
15128 int result;
15129 void *argp1 = 0 ;
15130 int res1 = 0 ;
15131 int val2 ;
15132 int ecode2 = 0 ;
15133 PyObject * obj0 = 0 ;
15134 PyObject * obj1 = 0 ;
15135 char * kwnames[] = {
15136 (char *) "self",(char *) "row", NULL
15137 };
15138
15139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15141 if (!SWIG_IsOK(res1)) {
15142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15143 }
15144 arg1 = reinterpret_cast< wxGrid * >(argp1);
15145 ecode2 = SWIG_AsVal_int(obj1, &val2);
15146 if (!SWIG_IsOK(ecode2)) {
15147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15148 }
15149 arg2 = static_cast< int >(val2);
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (int)(arg1)->GetRowSize(arg2);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 resultobj = SWIG_From_int(static_cast< int >(result));
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxGrid *arg1 = (wxGrid *) 0 ;
15166 int result;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 PyObject *swig_obj[1] ;
15170
15171 if (!args) SWIG_fail;
15172 swig_obj[0] = args;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15176 }
15177 arg1 = reinterpret_cast< wxGrid * >(argp1);
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (int)(arg1)->GetDefaultColSize();
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 resultobj = SWIG_From_int(static_cast< int >(result));
15185 return resultobj;
15186 fail:
15187 return NULL;
15188 }
15189
15190
15191 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15192 PyObject *resultobj = 0;
15193 wxGrid *arg1 = (wxGrid *) 0 ;
15194 int arg2 ;
15195 int result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 int val2 ;
15199 int ecode2 = 0 ;
15200 PyObject * obj0 = 0 ;
15201 PyObject * obj1 = 0 ;
15202 char * kwnames[] = {
15203 (char *) "self",(char *) "col", NULL
15204 };
15205
15206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15208 if (!SWIG_IsOK(res1)) {
15209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15210 }
15211 arg1 = reinterpret_cast< wxGrid * >(argp1);
15212 ecode2 = SWIG_AsVal_int(obj1, &val2);
15213 if (!SWIG_IsOK(ecode2)) {
15214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15215 }
15216 arg2 = static_cast< int >(val2);
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (int)(arg1)->GetColSize(arg2);
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 resultobj = SWIG_From_int(static_cast< int >(result));
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15231 PyObject *resultobj = 0;
15232 wxGrid *arg1 = (wxGrid *) 0 ;
15233 wxColour result;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 PyObject *swig_obj[1] ;
15237
15238 if (!args) SWIG_fail;
15239 swig_obj[0] = args;
15240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15243 }
15244 arg1 = reinterpret_cast< wxGrid * >(argp1);
15245 {
15246 PyThreadState* __tstate = wxPyBeginAllowThreads();
15247 result = (arg1)->GetDefaultCellBackgroundColour();
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj = 0;
15260 wxGrid *arg1 = (wxGrid *) 0 ;
15261 int arg2 ;
15262 int arg3 ;
15263 wxColour result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 int val2 ;
15267 int ecode2 = 0 ;
15268 int val3 ;
15269 int ecode3 = 0 ;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 PyObject * obj2 = 0 ;
15273 char * kwnames[] = {
15274 (char *) "self",(char *) "row",(char *) "col", NULL
15275 };
15276
15277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15279 if (!SWIG_IsOK(res1)) {
15280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15281 }
15282 arg1 = reinterpret_cast< wxGrid * >(argp1);
15283 ecode2 = SWIG_AsVal_int(obj1, &val2);
15284 if (!SWIG_IsOK(ecode2)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15286 }
15287 arg2 = static_cast< int >(val2);
15288 ecode3 = SWIG_AsVal_int(obj2, &val3);
15289 if (!SWIG_IsOK(ecode3)) {
15290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15291 }
15292 arg3 = static_cast< int >(val3);
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15296 wxPyEndAllowThreads(__tstate);
15297 if (PyErr_Occurred()) SWIG_fail;
15298 }
15299 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15307 PyObject *resultobj = 0;
15308 wxGrid *arg1 = (wxGrid *) 0 ;
15309 wxColour result;
15310 void *argp1 = 0 ;
15311 int res1 = 0 ;
15312 PyObject *swig_obj[1] ;
15313
15314 if (!args) SWIG_fail;
15315 swig_obj[0] = args;
15316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15317 if (!SWIG_IsOK(res1)) {
15318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15319 }
15320 arg1 = reinterpret_cast< wxGrid * >(argp1);
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 result = (arg1)->GetDefaultCellTextColour();
15324 wxPyEndAllowThreads(__tstate);
15325 if (PyErr_Occurred()) SWIG_fail;
15326 }
15327 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj = 0;
15336 wxGrid *arg1 = (wxGrid *) 0 ;
15337 int arg2 ;
15338 int arg3 ;
15339 wxColour result;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 int val2 ;
15343 int ecode2 = 0 ;
15344 int val3 ;
15345 int ecode3 = 0 ;
15346 PyObject * obj0 = 0 ;
15347 PyObject * obj1 = 0 ;
15348 PyObject * obj2 = 0 ;
15349 char * kwnames[] = {
15350 (char *) "self",(char *) "row",(char *) "col", NULL
15351 };
15352
15353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15357 }
15358 arg1 = reinterpret_cast< wxGrid * >(argp1);
15359 ecode2 = SWIG_AsVal_int(obj1, &val2);
15360 if (!SWIG_IsOK(ecode2)) {
15361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15362 }
15363 arg2 = static_cast< int >(val2);
15364 ecode3 = SWIG_AsVal_int(obj2, &val3);
15365 if (!SWIG_IsOK(ecode3)) {
15366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15367 }
15368 arg3 = static_cast< int >(val3);
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (arg1)->GetCellTextColour(arg2,arg3);
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15383 PyObject *resultobj = 0;
15384 wxGrid *arg1 = (wxGrid *) 0 ;
15385 wxFont result;
15386 void *argp1 = 0 ;
15387 int res1 = 0 ;
15388 PyObject *swig_obj[1] ;
15389
15390 if (!args) SWIG_fail;
15391 swig_obj[0] = args;
15392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15395 }
15396 arg1 = reinterpret_cast< wxGrid * >(argp1);
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (arg1)->GetDefaultCellFont();
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15411 PyObject *resultobj = 0;
15412 wxGrid *arg1 = (wxGrid *) 0 ;
15413 int arg2 ;
15414 int arg3 ;
15415 wxFont result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 int val2 ;
15419 int ecode2 = 0 ;
15420 int val3 ;
15421 int ecode3 = 0 ;
15422 PyObject * obj0 = 0 ;
15423 PyObject * obj1 = 0 ;
15424 PyObject * obj2 = 0 ;
15425 char * kwnames[] = {
15426 (char *) "self",(char *) "row",(char *) "col", NULL
15427 };
15428
15429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15433 }
15434 arg1 = reinterpret_cast< wxGrid * >(argp1);
15435 ecode2 = SWIG_AsVal_int(obj1, &val2);
15436 if (!SWIG_IsOK(ecode2)) {
15437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15438 }
15439 arg2 = static_cast< int >(val2);
15440 ecode3 = SWIG_AsVal_int(obj2, &val3);
15441 if (!SWIG_IsOK(ecode3)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15443 }
15444 arg3 = static_cast< int >(val3);
15445 {
15446 PyThreadState* __tstate = wxPyBeginAllowThreads();
15447 result = (arg1)->GetCellFont(arg2,arg3);
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15459 PyObject *resultobj = 0;
15460 wxGrid *arg1 = (wxGrid *) 0 ;
15461 int *arg2 = (int *) 0 ;
15462 int *arg3 = (int *) 0 ;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 int temp2 ;
15466 int res2 = SWIG_TMPOBJ ;
15467 int temp3 ;
15468 int res3 = SWIG_TMPOBJ ;
15469 PyObject *swig_obj[1] ;
15470
15471 arg2 = &temp2;
15472 arg3 = &temp3;
15473 if (!args) SWIG_fail;
15474 swig_obj[0] = args;
15475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15476 if (!SWIG_IsOK(res1)) {
15477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15478 }
15479 arg1 = reinterpret_cast< wxGrid * >(argp1);
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15483 wxPyEndAllowThreads(__tstate);
15484 if (PyErr_Occurred()) SWIG_fail;
15485 }
15486 resultobj = SWIG_Py_Void();
15487 if (SWIG_IsTmpObj(res2)) {
15488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15489 } else {
15490 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15492 }
15493 if (SWIG_IsTmpObj(res3)) {
15494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15495 } else {
15496 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15497 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15498 }
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj = 0;
15507 wxGrid *arg1 = (wxGrid *) 0 ;
15508 int arg2 ;
15509 int arg3 ;
15510 int *arg4 = (int *) 0 ;
15511 int *arg5 = (int *) 0 ;
15512 void *argp1 = 0 ;
15513 int res1 = 0 ;
15514 int val2 ;
15515 int ecode2 = 0 ;
15516 int val3 ;
15517 int ecode3 = 0 ;
15518 int temp4 ;
15519 int res4 = SWIG_TMPOBJ ;
15520 int temp5 ;
15521 int res5 = SWIG_TMPOBJ ;
15522 PyObject * obj0 = 0 ;
15523 PyObject * obj1 = 0 ;
15524 PyObject * obj2 = 0 ;
15525 char * kwnames[] = {
15526 (char *) "self",(char *) "row",(char *) "col", NULL
15527 };
15528
15529 arg4 = &temp4;
15530 arg5 = &temp5;
15531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15535 }
15536 arg1 = reinterpret_cast< wxGrid * >(argp1);
15537 ecode2 = SWIG_AsVal_int(obj1, &val2);
15538 if (!SWIG_IsOK(ecode2)) {
15539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15540 }
15541 arg2 = static_cast< int >(val2);
15542 ecode3 = SWIG_AsVal_int(obj2, &val3);
15543 if (!SWIG_IsOK(ecode3)) {
15544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15545 }
15546 arg3 = static_cast< int >(val3);
15547 {
15548 PyThreadState* __tstate = wxPyBeginAllowThreads();
15549 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 resultobj = SWIG_Py_Void();
15554 if (SWIG_IsTmpObj(res4)) {
15555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15556 } else {
15557 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15559 }
15560 if (SWIG_IsTmpObj(res5)) {
15561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15562 } else {
15563 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15565 }
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15573 PyObject *resultobj = 0;
15574 wxGrid *arg1 = (wxGrid *) 0 ;
15575 bool result;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 PyObject *swig_obj[1] ;
15579
15580 if (!args) SWIG_fail;
15581 swig_obj[0] = args;
15582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15585 }
15586 arg1 = reinterpret_cast< wxGrid * >(argp1);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 result = (bool)(arg1)->GetDefaultCellOverflow();
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 {
15594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15595 }
15596 return resultobj;
15597 fail:
15598 return NULL;
15599 }
15600
15601
15602 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15603 PyObject *resultobj = 0;
15604 wxGrid *arg1 = (wxGrid *) 0 ;
15605 int arg2 ;
15606 int arg3 ;
15607 bool result;
15608 void *argp1 = 0 ;
15609 int res1 = 0 ;
15610 int val2 ;
15611 int ecode2 = 0 ;
15612 int val3 ;
15613 int ecode3 = 0 ;
15614 PyObject * obj0 = 0 ;
15615 PyObject * obj1 = 0 ;
15616 PyObject * obj2 = 0 ;
15617 char * kwnames[] = {
15618 (char *) "self",(char *) "row",(char *) "col", NULL
15619 };
15620
15621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15623 if (!SWIG_IsOK(res1)) {
15624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15625 }
15626 arg1 = reinterpret_cast< wxGrid * >(argp1);
15627 ecode2 = SWIG_AsVal_int(obj1, &val2);
15628 if (!SWIG_IsOK(ecode2)) {
15629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15630 }
15631 arg2 = static_cast< int >(val2);
15632 ecode3 = SWIG_AsVal_int(obj2, &val3);
15633 if (!SWIG_IsOK(ecode3)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15635 }
15636 arg3 = static_cast< int >(val3);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 {
15644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15645 }
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj = 0;
15654 wxGrid *arg1 = (wxGrid *) 0 ;
15655 int arg2 ;
15656 int arg3 ;
15657 int *arg4 = (int *) 0 ;
15658 int *arg5 = (int *) 0 ;
15659 void *argp1 = 0 ;
15660 int res1 = 0 ;
15661 int val2 ;
15662 int ecode2 = 0 ;
15663 int val3 ;
15664 int ecode3 = 0 ;
15665 int temp4 ;
15666 int res4 = SWIG_TMPOBJ ;
15667 int temp5 ;
15668 int res5 = SWIG_TMPOBJ ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 PyObject * obj2 = 0 ;
15672 char * kwnames[] = {
15673 (char *) "self",(char *) "row",(char *) "col", NULL
15674 };
15675
15676 arg4 = &temp4;
15677 arg5 = &temp5;
15678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15680 if (!SWIG_IsOK(res1)) {
15681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15682 }
15683 arg1 = reinterpret_cast< wxGrid * >(argp1);
15684 ecode2 = SWIG_AsVal_int(obj1, &val2);
15685 if (!SWIG_IsOK(ecode2)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15687 }
15688 arg2 = static_cast< int >(val2);
15689 ecode3 = SWIG_AsVal_int(obj2, &val3);
15690 if (!SWIG_IsOK(ecode3)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15692 }
15693 arg3 = static_cast< int >(val3);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 if (SWIG_IsTmpObj(res4)) {
15702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15703 } else {
15704 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15706 }
15707 if (SWIG_IsTmpObj(res5)) {
15708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15709 } else {
15710 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15712 }
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15720 PyObject *resultobj = 0;
15721 wxGrid *arg1 = (wxGrid *) 0 ;
15722 int arg2 ;
15723 bool arg3 = (bool) false ;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 int val2 ;
15727 int ecode2 = 0 ;
15728 bool val3 ;
15729 int ecode3 = 0 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 PyObject * obj2 = 0 ;
15733 char * kwnames[] = {
15734 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15735 };
15736
15737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15739 if (!SWIG_IsOK(res1)) {
15740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15741 }
15742 arg1 = reinterpret_cast< wxGrid * >(argp1);
15743 ecode2 = SWIG_AsVal_int(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15746 }
15747 arg2 = static_cast< int >(val2);
15748 if (obj2) {
15749 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15750 if (!SWIG_IsOK(ecode3)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15752 }
15753 arg3 = static_cast< bool >(val3);
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 (arg1)->SetDefaultRowSize(arg2,arg3);
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 resultobj = SWIG_Py_Void();
15762 return resultobj;
15763 fail:
15764 return NULL;
15765 }
15766
15767
15768 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15769 PyObject *resultobj = 0;
15770 wxGrid *arg1 = (wxGrid *) 0 ;
15771 int arg2 ;
15772 int arg3 ;
15773 void *argp1 = 0 ;
15774 int res1 = 0 ;
15775 int val2 ;
15776 int ecode2 = 0 ;
15777 int val3 ;
15778 int ecode3 = 0 ;
15779 PyObject * obj0 = 0 ;
15780 PyObject * obj1 = 0 ;
15781 PyObject * obj2 = 0 ;
15782 char * kwnames[] = {
15783 (char *) "self",(char *) "row",(char *) "height", NULL
15784 };
15785
15786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15788 if (!SWIG_IsOK(res1)) {
15789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15790 }
15791 arg1 = reinterpret_cast< wxGrid * >(argp1);
15792 ecode2 = SWIG_AsVal_int(obj1, &val2);
15793 if (!SWIG_IsOK(ecode2)) {
15794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15795 }
15796 arg2 = static_cast< int >(val2);
15797 ecode3 = SWIG_AsVal_int(obj2, &val3);
15798 if (!SWIG_IsOK(ecode3)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15800 }
15801 arg3 = static_cast< int >(val3);
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 (arg1)->SetRowSize(arg2,arg3);
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 resultobj = SWIG_Py_Void();
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj = 0;
15817 wxGrid *arg1 = (wxGrid *) 0 ;
15818 int arg2 ;
15819 bool arg3 = (bool) false ;
15820 void *argp1 = 0 ;
15821 int res1 = 0 ;
15822 int val2 ;
15823 int ecode2 = 0 ;
15824 bool val3 ;
15825 int ecode3 = 0 ;
15826 PyObject * obj0 = 0 ;
15827 PyObject * obj1 = 0 ;
15828 PyObject * obj2 = 0 ;
15829 char * kwnames[] = {
15830 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15831 };
15832
15833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15835 if (!SWIG_IsOK(res1)) {
15836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15837 }
15838 arg1 = reinterpret_cast< wxGrid * >(argp1);
15839 ecode2 = SWIG_AsVal_int(obj1, &val2);
15840 if (!SWIG_IsOK(ecode2)) {
15841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15842 }
15843 arg2 = static_cast< int >(val2);
15844 if (obj2) {
15845 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15846 if (!SWIG_IsOK(ecode3)) {
15847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15848 }
15849 arg3 = static_cast< bool >(val3);
15850 }
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 (arg1)->SetDefaultColSize(arg2,arg3);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_Py_Void();
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 wxGrid *arg1 = (wxGrid *) 0 ;
15867 int arg2 ;
15868 int arg3 ;
15869 void *argp1 = 0 ;
15870 int res1 = 0 ;
15871 int val2 ;
15872 int ecode2 = 0 ;
15873 int val3 ;
15874 int ecode3 = 0 ;
15875 PyObject * obj0 = 0 ;
15876 PyObject * obj1 = 0 ;
15877 PyObject * obj2 = 0 ;
15878 char * kwnames[] = {
15879 (char *) "self",(char *) "col",(char *) "width", NULL
15880 };
15881
15882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15884 if (!SWIG_IsOK(res1)) {
15885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15886 }
15887 arg1 = reinterpret_cast< wxGrid * >(argp1);
15888 ecode2 = SWIG_AsVal_int(obj1, &val2);
15889 if (!SWIG_IsOK(ecode2)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15891 }
15892 arg2 = static_cast< int >(val2);
15893 ecode3 = SWIG_AsVal_int(obj2, &val3);
15894 if (!SWIG_IsOK(ecode3)) {
15895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15896 }
15897 arg3 = static_cast< int >(val3);
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 (arg1)->SetColSize(arg2,arg3);
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 resultobj = SWIG_Py_Void();
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj = 0;
15913 wxGrid *arg1 = (wxGrid *) 0 ;
15914 int arg2 ;
15915 int result;
15916 void *argp1 = 0 ;
15917 int res1 = 0 ;
15918 int val2 ;
15919 int ecode2 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char * kwnames[] = {
15923 (char *) "self",(char *) "colPos", NULL
15924 };
15925
15926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15930 }
15931 arg1 = reinterpret_cast< wxGrid * >(argp1);
15932 ecode2 = SWIG_AsVal_int(obj1, &val2);
15933 if (!SWIG_IsOK(ecode2)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15935 }
15936 arg2 = static_cast< int >(val2);
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_From_int(static_cast< int >(result));
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj = 0;
15952 wxGrid *arg1 = (wxGrid *) 0 ;
15953 int arg2 ;
15954 int arg3 ;
15955 void *argp1 = 0 ;
15956 int res1 = 0 ;
15957 int val2 ;
15958 int ecode2 = 0 ;
15959 int val3 ;
15960 int ecode3 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 char * kwnames[] = {
15965 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15966 };
15967
15968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15970 if (!SWIG_IsOK(res1)) {
15971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15972 }
15973 arg1 = reinterpret_cast< wxGrid * >(argp1);
15974 ecode2 = SWIG_AsVal_int(obj1, &val2);
15975 if (!SWIG_IsOK(ecode2)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15977 }
15978 arg2 = static_cast< int >(val2);
15979 ecode3 = SWIG_AsVal_int(obj2, &val3);
15980 if (!SWIG_IsOK(ecode3)) {
15981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15982 }
15983 arg3 = static_cast< int >(val3);
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 (arg1)->SetColPos(arg2,arg3);
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 resultobj = SWIG_Py_Void();
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15998 PyObject *resultobj = 0;
15999 wxGrid *arg1 = (wxGrid *) 0 ;
16000 int arg2 ;
16001 int result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 int val2 ;
16005 int ecode2 = 0 ;
16006 PyObject * obj0 = 0 ;
16007 PyObject * obj1 = 0 ;
16008 char * kwnames[] = {
16009 (char *) "self",(char *) "colID", NULL
16010 };
16011
16012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16014 if (!SWIG_IsOK(res1)) {
16015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16016 }
16017 arg1 = reinterpret_cast< wxGrid * >(argp1);
16018 ecode2 = SWIG_AsVal_int(obj1, &val2);
16019 if (!SWIG_IsOK(ecode2)) {
16020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16021 }
16022 arg2 = static_cast< int >(val2);
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 resultobj = SWIG_From_int(static_cast< int >(result));
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = 0;
16038 wxGrid *arg1 = (wxGrid *) 0 ;
16039 int arg2 ;
16040 bool arg3 = (bool) true ;
16041 void *argp1 = 0 ;
16042 int res1 = 0 ;
16043 int val2 ;
16044 int ecode2 = 0 ;
16045 bool val3 ;
16046 int ecode3 = 0 ;
16047 PyObject * obj0 = 0 ;
16048 PyObject * obj1 = 0 ;
16049 PyObject * obj2 = 0 ;
16050 char * kwnames[] = {
16051 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16052 };
16053
16054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16058 }
16059 arg1 = reinterpret_cast< wxGrid * >(argp1);
16060 ecode2 = SWIG_AsVal_int(obj1, &val2);
16061 if (!SWIG_IsOK(ecode2)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16063 }
16064 arg2 = static_cast< int >(val2);
16065 if (obj2) {
16066 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16067 if (!SWIG_IsOK(ecode3)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16069 }
16070 arg3 = static_cast< bool >(val3);
16071 }
16072 {
16073 PyThreadState* __tstate = wxPyBeginAllowThreads();
16074 (arg1)->AutoSizeColumn(arg2,arg3);
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 resultobj = SWIG_Py_Void();
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj = 0;
16087 wxGrid *arg1 = (wxGrid *) 0 ;
16088 int arg2 ;
16089 bool arg3 = (bool) true ;
16090 void *argp1 = 0 ;
16091 int res1 = 0 ;
16092 int val2 ;
16093 int ecode2 = 0 ;
16094 bool val3 ;
16095 int ecode3 = 0 ;
16096 PyObject * obj0 = 0 ;
16097 PyObject * obj1 = 0 ;
16098 PyObject * obj2 = 0 ;
16099 char * kwnames[] = {
16100 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16101 };
16102
16103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16107 }
16108 arg1 = reinterpret_cast< wxGrid * >(argp1);
16109 ecode2 = SWIG_AsVal_int(obj1, &val2);
16110 if (!SWIG_IsOK(ecode2)) {
16111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16112 }
16113 arg2 = static_cast< int >(val2);
16114 if (obj2) {
16115 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16116 if (!SWIG_IsOK(ecode3)) {
16117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16118 }
16119 arg3 = static_cast< bool >(val3);
16120 }
16121 {
16122 PyThreadState* __tstate = wxPyBeginAllowThreads();
16123 (arg1)->AutoSizeRow(arg2,arg3);
16124 wxPyEndAllowThreads(__tstate);
16125 if (PyErr_Occurred()) SWIG_fail;
16126 }
16127 resultobj = SWIG_Py_Void();
16128 return resultobj;
16129 fail:
16130 return NULL;
16131 }
16132
16133
16134 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16135 PyObject *resultobj = 0;
16136 wxGrid *arg1 = (wxGrid *) 0 ;
16137 bool arg2 = (bool) true ;
16138 void *argp1 = 0 ;
16139 int res1 = 0 ;
16140 bool val2 ;
16141 int ecode2 = 0 ;
16142 PyObject * obj0 = 0 ;
16143 PyObject * obj1 = 0 ;
16144 char * kwnames[] = {
16145 (char *) "self",(char *) "setAsMin", NULL
16146 };
16147
16148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16150 if (!SWIG_IsOK(res1)) {
16151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16152 }
16153 arg1 = reinterpret_cast< wxGrid * >(argp1);
16154 if (obj1) {
16155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16156 if (!SWIG_IsOK(ecode2)) {
16157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16158 }
16159 arg2 = static_cast< bool >(val2);
16160 }
16161 {
16162 PyThreadState* __tstate = wxPyBeginAllowThreads();
16163 (arg1)->AutoSizeColumns(arg2);
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 resultobj = SWIG_Py_Void();
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj = 0;
16176 wxGrid *arg1 = (wxGrid *) 0 ;
16177 bool arg2 = (bool) true ;
16178 void *argp1 = 0 ;
16179 int res1 = 0 ;
16180 bool val2 ;
16181 int ecode2 = 0 ;
16182 PyObject * obj0 = 0 ;
16183 PyObject * obj1 = 0 ;
16184 char * kwnames[] = {
16185 (char *) "self",(char *) "setAsMin", NULL
16186 };
16187
16188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16190 if (!SWIG_IsOK(res1)) {
16191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16192 }
16193 arg1 = reinterpret_cast< wxGrid * >(argp1);
16194 if (obj1) {
16195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16196 if (!SWIG_IsOK(ecode2)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16198 }
16199 arg2 = static_cast< bool >(val2);
16200 }
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 (arg1)->AutoSizeRows(arg2);
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_Py_Void();
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16215 PyObject *resultobj = 0;
16216 wxGrid *arg1 = (wxGrid *) 0 ;
16217 void *argp1 = 0 ;
16218 int res1 = 0 ;
16219 PyObject *swig_obj[1] ;
16220
16221 if (!args) SWIG_fail;
16222 swig_obj[0] = args;
16223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16226 }
16227 arg1 = reinterpret_cast< wxGrid * >(argp1);
16228 {
16229 PyThreadState* __tstate = wxPyBeginAllowThreads();
16230 (arg1)->AutoSize();
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 resultobj = SWIG_Py_Void();
16235 return resultobj;
16236 fail:
16237 return NULL;
16238 }
16239
16240
16241 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16242 PyObject *resultobj = 0;
16243 wxGrid *arg1 = (wxGrid *) 0 ;
16244 int arg2 ;
16245 void *argp1 = 0 ;
16246 int res1 = 0 ;
16247 int val2 ;
16248 int ecode2 = 0 ;
16249 PyObject * obj0 = 0 ;
16250 PyObject * obj1 = 0 ;
16251 char * kwnames[] = {
16252 (char *) "self",(char *) "row", NULL
16253 };
16254
16255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16257 if (!SWIG_IsOK(res1)) {
16258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16259 }
16260 arg1 = reinterpret_cast< wxGrid * >(argp1);
16261 ecode2 = SWIG_AsVal_int(obj1, &val2);
16262 if (!SWIG_IsOK(ecode2)) {
16263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16264 }
16265 arg2 = static_cast< int >(val2);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 (arg1)->AutoSizeRowLabelSize(arg2);
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 resultobj = SWIG_Py_Void();
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxGrid *arg1 = (wxGrid *) 0 ;
16282 int arg2 ;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 int val2 ;
16286 int ecode2 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "col", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16297 }
16298 arg1 = reinterpret_cast< wxGrid * >(argp1);
16299 ecode2 = SWIG_AsVal_int(obj1, &val2);
16300 if (!SWIG_IsOK(ecode2)) {
16301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16302 }
16303 arg2 = static_cast< int >(val2);
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 (arg1)->AutoSizeColLabelSize(arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 resultobj = SWIG_Py_Void();
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxGrid *arg1 = (wxGrid *) 0 ;
16320 int arg2 ;
16321 int arg3 ;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 int val2 ;
16325 int ecode2 = 0 ;
16326 int val3 ;
16327 int ecode3 = 0 ;
16328 PyObject * obj0 = 0 ;
16329 PyObject * obj1 = 0 ;
16330 PyObject * obj2 = 0 ;
16331 char * kwnames[] = {
16332 (char *) "self",(char *) "col",(char *) "width", NULL
16333 };
16334
16335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16337 if (!SWIG_IsOK(res1)) {
16338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16339 }
16340 arg1 = reinterpret_cast< wxGrid * >(argp1);
16341 ecode2 = SWIG_AsVal_int(obj1, &val2);
16342 if (!SWIG_IsOK(ecode2)) {
16343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16344 }
16345 arg2 = static_cast< int >(val2);
16346 ecode3 = SWIG_AsVal_int(obj2, &val3);
16347 if (!SWIG_IsOK(ecode3)) {
16348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16349 }
16350 arg3 = static_cast< int >(val3);
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetColMinimalWidth(arg2,arg3);
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_Py_Void();
16358 return resultobj;
16359 fail:
16360 return NULL;
16361 }
16362
16363
16364 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16365 PyObject *resultobj = 0;
16366 wxGrid *arg1 = (wxGrid *) 0 ;
16367 int arg2 ;
16368 int arg3 ;
16369 void *argp1 = 0 ;
16370 int res1 = 0 ;
16371 int val2 ;
16372 int ecode2 = 0 ;
16373 int val3 ;
16374 int ecode3 = 0 ;
16375 PyObject * obj0 = 0 ;
16376 PyObject * obj1 = 0 ;
16377 PyObject * obj2 = 0 ;
16378 char * kwnames[] = {
16379 (char *) "self",(char *) "row",(char *) "width", NULL
16380 };
16381
16382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16384 if (!SWIG_IsOK(res1)) {
16385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16386 }
16387 arg1 = reinterpret_cast< wxGrid * >(argp1);
16388 ecode2 = SWIG_AsVal_int(obj1, &val2);
16389 if (!SWIG_IsOK(ecode2)) {
16390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16391 }
16392 arg2 = static_cast< int >(val2);
16393 ecode3 = SWIG_AsVal_int(obj2, &val3);
16394 if (!SWIG_IsOK(ecode3)) {
16395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16396 }
16397 arg3 = static_cast< int >(val3);
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 (arg1)->SetRowMinimalHeight(arg2,arg3);
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 resultobj = SWIG_Py_Void();
16405 return resultobj;
16406 fail:
16407 return NULL;
16408 }
16409
16410
16411 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16412 PyObject *resultobj = 0;
16413 wxGrid *arg1 = (wxGrid *) 0 ;
16414 int arg2 ;
16415 void *argp1 = 0 ;
16416 int res1 = 0 ;
16417 int val2 ;
16418 int ecode2 = 0 ;
16419 PyObject * obj0 = 0 ;
16420 PyObject * obj1 = 0 ;
16421 char * kwnames[] = {
16422 (char *) "self",(char *) "width", NULL
16423 };
16424
16425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16427 if (!SWIG_IsOK(res1)) {
16428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16429 }
16430 arg1 = reinterpret_cast< wxGrid * >(argp1);
16431 ecode2 = SWIG_AsVal_int(obj1, &val2);
16432 if (!SWIG_IsOK(ecode2)) {
16433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16434 }
16435 arg2 = static_cast< int >(val2);
16436 {
16437 PyThreadState* __tstate = wxPyBeginAllowThreads();
16438 (arg1)->SetColMinimalAcceptableWidth(arg2);
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 resultobj = SWIG_Py_Void();
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj = 0;
16451 wxGrid *arg1 = (wxGrid *) 0 ;
16452 int arg2 ;
16453 void *argp1 = 0 ;
16454 int res1 = 0 ;
16455 int val2 ;
16456 int ecode2 = 0 ;
16457 PyObject * obj0 = 0 ;
16458 PyObject * obj1 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "width", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16467 }
16468 arg1 = reinterpret_cast< wxGrid * >(argp1);
16469 ecode2 = SWIG_AsVal_int(obj1, &val2);
16470 if (!SWIG_IsOK(ecode2)) {
16471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16472 }
16473 arg2 = static_cast< int >(val2);
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 resultobj = SWIG_Py_Void();
16481 return resultobj;
16482 fail:
16483 return NULL;
16484 }
16485
16486
16487 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16488 PyObject *resultobj = 0;
16489 wxGrid *arg1 = (wxGrid *) 0 ;
16490 int result;
16491 void *argp1 = 0 ;
16492 int res1 = 0 ;
16493 PyObject *swig_obj[1] ;
16494
16495 if (!args) SWIG_fail;
16496 swig_obj[0] = args;
16497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16498 if (!SWIG_IsOK(res1)) {
16499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16500 }
16501 arg1 = reinterpret_cast< wxGrid * >(argp1);
16502 {
16503 PyThreadState* __tstate = wxPyBeginAllowThreads();
16504 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_From_int(static_cast< int >(result));
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16516 PyObject *resultobj = 0;
16517 wxGrid *arg1 = (wxGrid *) 0 ;
16518 int result;
16519 void *argp1 = 0 ;
16520 int res1 = 0 ;
16521 PyObject *swig_obj[1] ;
16522
16523 if (!args) SWIG_fail;
16524 swig_obj[0] = args;
16525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16528 }
16529 arg1 = reinterpret_cast< wxGrid * >(argp1);
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 resultobj = SWIG_From_int(static_cast< int >(result));
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj = 0;
16545 wxGrid *arg1 = (wxGrid *) 0 ;
16546 wxColour *arg2 = 0 ;
16547 void *argp1 = 0 ;
16548 int res1 = 0 ;
16549 wxColour temp2 ;
16550 PyObject * obj0 = 0 ;
16551 PyObject * obj1 = 0 ;
16552 char * kwnames[] = {
16553 (char *) "self",(char *)"arg2", NULL
16554 };
16555
16556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16558 if (!SWIG_IsOK(res1)) {
16559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16560 }
16561 arg1 = reinterpret_cast< wxGrid * >(argp1);
16562 {
16563 arg2 = &temp2;
16564 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16569 wxPyEndAllowThreads(__tstate);
16570 if (PyErr_Occurred()) SWIG_fail;
16571 }
16572 resultobj = SWIG_Py_Void();
16573 return resultobj;
16574 fail:
16575 return NULL;
16576 }
16577
16578
16579 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16580 PyObject *resultobj = 0;
16581 wxGrid *arg1 = (wxGrid *) 0 ;
16582 int arg2 ;
16583 int arg3 ;
16584 wxColour *arg4 = 0 ;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 int val2 ;
16588 int ecode2 = 0 ;
16589 int val3 ;
16590 int ecode3 = 0 ;
16591 wxColour temp4 ;
16592 PyObject * obj0 = 0 ;
16593 PyObject * obj1 = 0 ;
16594 PyObject * obj2 = 0 ;
16595 PyObject * obj3 = 0 ;
16596 char * kwnames[] = {
16597 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16598 };
16599
16600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16602 if (!SWIG_IsOK(res1)) {
16603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16604 }
16605 arg1 = reinterpret_cast< wxGrid * >(argp1);
16606 ecode2 = SWIG_AsVal_int(obj1, &val2);
16607 if (!SWIG_IsOK(ecode2)) {
16608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16609 }
16610 arg2 = static_cast< int >(val2);
16611 ecode3 = SWIG_AsVal_int(obj2, &val3);
16612 if (!SWIG_IsOK(ecode3)) {
16613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16614 }
16615 arg3 = static_cast< int >(val3);
16616 {
16617 arg4 = &temp4;
16618 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16619 }
16620 {
16621 PyThreadState* __tstate = wxPyBeginAllowThreads();
16622 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 resultobj = SWIG_Py_Void();
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj = 0;
16635 wxGrid *arg1 = (wxGrid *) 0 ;
16636 wxColour *arg2 = 0 ;
16637 void *argp1 = 0 ;
16638 int res1 = 0 ;
16639 wxColour temp2 ;
16640 PyObject * obj0 = 0 ;
16641 PyObject * obj1 = 0 ;
16642 char * kwnames[] = {
16643 (char *) "self",(char *)"arg2", NULL
16644 };
16645
16646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16650 }
16651 arg1 = reinterpret_cast< wxGrid * >(argp1);
16652 {
16653 arg2 = &temp2;
16654 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16655 }
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 resultobj = SWIG_Py_Void();
16663 return resultobj;
16664 fail:
16665 return NULL;
16666 }
16667
16668
16669 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj = 0;
16671 wxGrid *arg1 = (wxGrid *) 0 ;
16672 int arg2 ;
16673 int arg3 ;
16674 wxColour *arg4 = 0 ;
16675 void *argp1 = 0 ;
16676 int res1 = 0 ;
16677 int val2 ;
16678 int ecode2 = 0 ;
16679 int val3 ;
16680 int ecode3 = 0 ;
16681 wxColour temp4 ;
16682 PyObject * obj0 = 0 ;
16683 PyObject * obj1 = 0 ;
16684 PyObject * obj2 = 0 ;
16685 PyObject * obj3 = 0 ;
16686 char * kwnames[] = {
16687 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16688 };
16689
16690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16694 }
16695 arg1 = reinterpret_cast< wxGrid * >(argp1);
16696 ecode2 = SWIG_AsVal_int(obj1, &val2);
16697 if (!SWIG_IsOK(ecode2)) {
16698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16699 }
16700 arg2 = static_cast< int >(val2);
16701 ecode3 = SWIG_AsVal_int(obj2, &val3);
16702 if (!SWIG_IsOK(ecode3)) {
16703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16704 }
16705 arg3 = static_cast< int >(val3);
16706 {
16707 arg4 = &temp4;
16708 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16709 }
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_Py_Void();
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxGrid *arg1 = (wxGrid *) 0 ;
16726 wxFont *arg2 = 0 ;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 void *argp2 = 0 ;
16730 int res2 = 0 ;
16731 PyObject * obj0 = 0 ;
16732 PyObject * obj1 = 0 ;
16733 char * kwnames[] = {
16734 (char *) "self",(char *)"arg2", NULL
16735 };
16736
16737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16739 if (!SWIG_IsOK(res1)) {
16740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16741 }
16742 arg1 = reinterpret_cast< wxGrid * >(argp1);
16743 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16744 if (!SWIG_IsOK(res2)) {
16745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16746 }
16747 if (!argp2) {
16748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16749 }
16750 arg2 = reinterpret_cast< wxFont * >(argp2);
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 resultobj = SWIG_Py_Void();
16758 return resultobj;
16759 fail:
16760 return NULL;
16761 }
16762
16763
16764 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16765 PyObject *resultobj = 0;
16766 wxGrid *arg1 = (wxGrid *) 0 ;
16767 int arg2 ;
16768 int arg3 ;
16769 wxFont *arg4 = 0 ;
16770 void *argp1 = 0 ;
16771 int res1 = 0 ;
16772 int val2 ;
16773 int ecode2 = 0 ;
16774 int val3 ;
16775 int ecode3 = 0 ;
16776 void *argp4 = 0 ;
16777 int res4 = 0 ;
16778 PyObject * obj0 = 0 ;
16779 PyObject * obj1 = 0 ;
16780 PyObject * obj2 = 0 ;
16781 PyObject * obj3 = 0 ;
16782 char * kwnames[] = {
16783 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16784 };
16785
16786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16788 if (!SWIG_IsOK(res1)) {
16789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16790 }
16791 arg1 = reinterpret_cast< wxGrid * >(argp1);
16792 ecode2 = SWIG_AsVal_int(obj1, &val2);
16793 if (!SWIG_IsOK(ecode2)) {
16794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16795 }
16796 arg2 = static_cast< int >(val2);
16797 ecode3 = SWIG_AsVal_int(obj2, &val3);
16798 if (!SWIG_IsOK(ecode3)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16800 }
16801 arg3 = static_cast< int >(val3);
16802 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16803 if (!SWIG_IsOK(res4)) {
16804 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16805 }
16806 if (!argp4) {
16807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16808 }
16809 arg4 = reinterpret_cast< wxFont * >(argp4);
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 resultobj = SWIG_Py_Void();
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj = 0;
16825 wxGrid *arg1 = (wxGrid *) 0 ;
16826 int arg2 ;
16827 int arg3 ;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 int val2 ;
16831 int ecode2 = 0 ;
16832 int val3 ;
16833 int ecode3 = 0 ;
16834 PyObject * obj0 = 0 ;
16835 PyObject * obj1 = 0 ;
16836 PyObject * obj2 = 0 ;
16837 char * kwnames[] = {
16838 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16839 };
16840
16841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16845 }
16846 arg1 = reinterpret_cast< wxGrid * >(argp1);
16847 ecode2 = SWIG_AsVal_int(obj1, &val2);
16848 if (!SWIG_IsOK(ecode2)) {
16849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16850 }
16851 arg2 = static_cast< int >(val2);
16852 ecode3 = SWIG_AsVal_int(obj2, &val3);
16853 if (!SWIG_IsOK(ecode3)) {
16854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16855 }
16856 arg3 = static_cast< int >(val3);
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16860 wxPyEndAllowThreads(__tstate);
16861 if (PyErr_Occurred()) SWIG_fail;
16862 }
16863 resultobj = SWIG_Py_Void();
16864 return resultobj;
16865 fail:
16866 return NULL;
16867 }
16868
16869
16870 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16871 PyObject *resultobj = 0;
16872 wxGrid *arg1 = (wxGrid *) 0 ;
16873 int arg2 ;
16874 int arg3 ;
16875 int arg4 ;
16876 int arg5 ;
16877 void *argp1 = 0 ;
16878 int res1 = 0 ;
16879 int val2 ;
16880 int ecode2 = 0 ;
16881 int val3 ;
16882 int ecode3 = 0 ;
16883 int val4 ;
16884 int ecode4 = 0 ;
16885 int val5 ;
16886 int ecode5 = 0 ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 PyObject * obj2 = 0 ;
16890 PyObject * obj3 = 0 ;
16891 PyObject * obj4 = 0 ;
16892 char * kwnames[] = {
16893 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16894 };
16895
16896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16898 if (!SWIG_IsOK(res1)) {
16899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16900 }
16901 arg1 = reinterpret_cast< wxGrid * >(argp1);
16902 ecode2 = SWIG_AsVal_int(obj1, &val2);
16903 if (!SWIG_IsOK(ecode2)) {
16904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16905 }
16906 arg2 = static_cast< int >(val2);
16907 ecode3 = SWIG_AsVal_int(obj2, &val3);
16908 if (!SWIG_IsOK(ecode3)) {
16909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16910 }
16911 arg3 = static_cast< int >(val3);
16912 ecode4 = SWIG_AsVal_int(obj3, &val4);
16913 if (!SWIG_IsOK(ecode4)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16915 }
16916 arg4 = static_cast< int >(val4);
16917 ecode5 = SWIG_AsVal_int(obj4, &val5);
16918 if (!SWIG_IsOK(ecode5)) {
16919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16920 }
16921 arg5 = static_cast< int >(val5);
16922 {
16923 PyThreadState* __tstate = wxPyBeginAllowThreads();
16924 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 resultobj = SWIG_Py_Void();
16929 return resultobj;
16930 fail:
16931 return NULL;
16932 }
16933
16934
16935 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16936 PyObject *resultobj = 0;
16937 wxGrid *arg1 = (wxGrid *) 0 ;
16938 bool arg2 ;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 bool val2 ;
16942 int ecode2 = 0 ;
16943 PyObject * obj0 = 0 ;
16944 PyObject * obj1 = 0 ;
16945 char * kwnames[] = {
16946 (char *) "self",(char *) "allow", NULL
16947 };
16948
16949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16951 if (!SWIG_IsOK(res1)) {
16952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16953 }
16954 arg1 = reinterpret_cast< wxGrid * >(argp1);
16955 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16956 if (!SWIG_IsOK(ecode2)) {
16957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16958 }
16959 arg2 = static_cast< bool >(val2);
16960 {
16961 PyThreadState* __tstate = wxPyBeginAllowThreads();
16962 (arg1)->SetDefaultCellOverflow(arg2);
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 resultobj = SWIG_Py_Void();
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj = 0;
16975 wxGrid *arg1 = (wxGrid *) 0 ;
16976 int arg2 ;
16977 int arg3 ;
16978 bool arg4 ;
16979 void *argp1 = 0 ;
16980 int res1 = 0 ;
16981 int val2 ;
16982 int ecode2 = 0 ;
16983 int val3 ;
16984 int ecode3 = 0 ;
16985 bool val4 ;
16986 int ecode4 = 0 ;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 PyObject * obj2 = 0 ;
16990 PyObject * obj3 = 0 ;
16991 char * kwnames[] = {
16992 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16993 };
16994
16995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16997 if (!SWIG_IsOK(res1)) {
16998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16999 }
17000 arg1 = reinterpret_cast< wxGrid * >(argp1);
17001 ecode2 = SWIG_AsVal_int(obj1, &val2);
17002 if (!SWIG_IsOK(ecode2)) {
17003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17004 }
17005 arg2 = static_cast< int >(val2);
17006 ecode3 = SWIG_AsVal_int(obj2, &val3);
17007 if (!SWIG_IsOK(ecode3)) {
17008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17009 }
17010 arg3 = static_cast< int >(val3);
17011 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17012 if (!SWIG_IsOK(ecode4)) {
17013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17014 }
17015 arg4 = static_cast< bool >(val4);
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 resultobj = SWIG_Py_Void();
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj = 0;
17031 wxGrid *arg1 = (wxGrid *) 0 ;
17032 int arg2 ;
17033 int arg3 ;
17034 int arg4 ;
17035 int arg5 ;
17036 void *argp1 = 0 ;
17037 int res1 = 0 ;
17038 int val2 ;
17039 int ecode2 = 0 ;
17040 int val3 ;
17041 int ecode3 = 0 ;
17042 int val4 ;
17043 int ecode4 = 0 ;
17044 int val5 ;
17045 int ecode5 = 0 ;
17046 PyObject * obj0 = 0 ;
17047 PyObject * obj1 = 0 ;
17048 PyObject * obj2 = 0 ;
17049 PyObject * obj3 = 0 ;
17050 PyObject * obj4 = 0 ;
17051 char * kwnames[] = {
17052 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17053 };
17054
17055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17057 if (!SWIG_IsOK(res1)) {
17058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17059 }
17060 arg1 = reinterpret_cast< wxGrid * >(argp1);
17061 ecode2 = SWIG_AsVal_int(obj1, &val2);
17062 if (!SWIG_IsOK(ecode2)) {
17063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17064 }
17065 arg2 = static_cast< int >(val2);
17066 ecode3 = SWIG_AsVal_int(obj2, &val3);
17067 if (!SWIG_IsOK(ecode3)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17069 }
17070 arg3 = static_cast< int >(val3);
17071 ecode4 = SWIG_AsVal_int(obj3, &val4);
17072 if (!SWIG_IsOK(ecode4)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17074 }
17075 arg4 = static_cast< int >(val4);
17076 ecode5 = SWIG_AsVal_int(obj4, &val5);
17077 if (!SWIG_IsOK(ecode5)) {
17078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17079 }
17080 arg5 = static_cast< int >(val5);
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17084 wxPyEndAllowThreads(__tstate);
17085 if (PyErr_Occurred()) SWIG_fail;
17086 }
17087 resultobj = SWIG_Py_Void();
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj = 0;
17096 wxGrid *arg1 = (wxGrid *) 0 ;
17097 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17098 void *argp1 = 0 ;
17099 int res1 = 0 ;
17100 void *argp2 = 0 ;
17101 int res2 = 0 ;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 char * kwnames[] = {
17105 (char *) "self",(char *) "renderer", NULL
17106 };
17107
17108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17110 if (!SWIG_IsOK(res1)) {
17111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17112 }
17113 arg1 = reinterpret_cast< wxGrid * >(argp1);
17114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17115 if (!SWIG_IsOK(res2)) {
17116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17117 }
17118 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 (arg1)->SetDefaultRenderer(arg2);
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = SWIG_Py_Void();
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj = 0;
17134 wxGrid *arg1 = (wxGrid *) 0 ;
17135 int arg2 ;
17136 int arg3 ;
17137 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17138 void *argp1 = 0 ;
17139 int res1 = 0 ;
17140 int val2 ;
17141 int ecode2 = 0 ;
17142 int val3 ;
17143 int ecode3 = 0 ;
17144 void *argp4 = 0 ;
17145 int res4 = 0 ;
17146 PyObject * obj0 = 0 ;
17147 PyObject * obj1 = 0 ;
17148 PyObject * obj2 = 0 ;
17149 PyObject * obj3 = 0 ;
17150 char * kwnames[] = {
17151 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17152 };
17153
17154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17156 if (!SWIG_IsOK(res1)) {
17157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17158 }
17159 arg1 = reinterpret_cast< wxGrid * >(argp1);
17160 ecode2 = SWIG_AsVal_int(obj1, &val2);
17161 if (!SWIG_IsOK(ecode2)) {
17162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17163 }
17164 arg2 = static_cast< int >(val2);
17165 ecode3 = SWIG_AsVal_int(obj2, &val3);
17166 if (!SWIG_IsOK(ecode3)) {
17167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17168 }
17169 arg3 = static_cast< int >(val3);
17170 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17171 if (!SWIG_IsOK(res4)) {
17172 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17173 }
17174 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17178 wxPyEndAllowThreads(__tstate);
17179 if (PyErr_Occurred()) SWIG_fail;
17180 }
17181 resultobj = SWIG_Py_Void();
17182 return resultobj;
17183 fail:
17184 return NULL;
17185 }
17186
17187
17188 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17189 PyObject *resultobj = 0;
17190 wxGrid *arg1 = (wxGrid *) 0 ;
17191 wxGridCellRenderer *result = 0 ;
17192 void *argp1 = 0 ;
17193 int res1 = 0 ;
17194 PyObject *swig_obj[1] ;
17195
17196 if (!args) SWIG_fail;
17197 swig_obj[0] = args;
17198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17199 if (!SWIG_IsOK(res1)) {
17200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17201 }
17202 arg1 = reinterpret_cast< wxGrid * >(argp1);
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17206 wxPyEndAllowThreads(__tstate);
17207 if (PyErr_Occurred()) SWIG_fail;
17208 }
17209 {
17210 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17211 }
17212 return resultobj;
17213 fail:
17214 return NULL;
17215 }
17216
17217
17218 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17219 PyObject *resultobj = 0;
17220 wxGrid *arg1 = (wxGrid *) 0 ;
17221 int arg2 ;
17222 int arg3 ;
17223 wxGridCellRenderer *result = 0 ;
17224 void *argp1 = 0 ;
17225 int res1 = 0 ;
17226 int val2 ;
17227 int ecode2 = 0 ;
17228 int val3 ;
17229 int ecode3 = 0 ;
17230 PyObject * obj0 = 0 ;
17231 PyObject * obj1 = 0 ;
17232 PyObject * obj2 = 0 ;
17233 char * kwnames[] = {
17234 (char *) "self",(char *) "row",(char *) "col", NULL
17235 };
17236
17237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17239 if (!SWIG_IsOK(res1)) {
17240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17241 }
17242 arg1 = reinterpret_cast< wxGrid * >(argp1);
17243 ecode2 = SWIG_AsVal_int(obj1, &val2);
17244 if (!SWIG_IsOK(ecode2)) {
17245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17246 }
17247 arg2 = static_cast< int >(val2);
17248 ecode3 = SWIG_AsVal_int(obj2, &val3);
17249 if (!SWIG_IsOK(ecode3)) {
17250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17251 }
17252 arg3 = static_cast< int >(val3);
17253 {
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17261 }
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj = 0;
17270 wxGrid *arg1 = (wxGrid *) 0 ;
17271 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17272 void *argp1 = 0 ;
17273 int res1 = 0 ;
17274 void *argp2 = 0 ;
17275 int res2 = 0 ;
17276 PyObject * obj0 = 0 ;
17277 PyObject * obj1 = 0 ;
17278 char * kwnames[] = {
17279 (char *) "self",(char *) "editor", NULL
17280 };
17281
17282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17284 if (!SWIG_IsOK(res1)) {
17285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17286 }
17287 arg1 = reinterpret_cast< wxGrid * >(argp1);
17288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17289 if (!SWIG_IsOK(res2)) {
17290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17291 }
17292 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 (arg1)->SetDefaultEditor(arg2);
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_Py_Void();
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17307 PyObject *resultobj = 0;
17308 wxGrid *arg1 = (wxGrid *) 0 ;
17309 int arg2 ;
17310 int arg3 ;
17311 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17312 void *argp1 = 0 ;
17313 int res1 = 0 ;
17314 int val2 ;
17315 int ecode2 = 0 ;
17316 int val3 ;
17317 int ecode3 = 0 ;
17318 void *argp4 = 0 ;
17319 int res4 = 0 ;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 PyObject * obj2 = 0 ;
17323 PyObject * obj3 = 0 ;
17324 char * kwnames[] = {
17325 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17326 };
17327
17328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17330 if (!SWIG_IsOK(res1)) {
17331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17332 }
17333 arg1 = reinterpret_cast< wxGrid * >(argp1);
17334 ecode2 = SWIG_AsVal_int(obj1, &val2);
17335 if (!SWIG_IsOK(ecode2)) {
17336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17337 }
17338 arg2 = static_cast< int >(val2);
17339 ecode3 = SWIG_AsVal_int(obj2, &val3);
17340 if (!SWIG_IsOK(ecode3)) {
17341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17342 }
17343 arg3 = static_cast< int >(val3);
17344 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17345 if (!SWIG_IsOK(res4)) {
17346 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17347 }
17348 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17349 {
17350 PyThreadState* __tstate = wxPyBeginAllowThreads();
17351 (arg1)->SetCellEditor(arg2,arg3,arg4);
17352 wxPyEndAllowThreads(__tstate);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 }
17355 resultobj = SWIG_Py_Void();
17356 return resultobj;
17357 fail:
17358 return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 PyObject *resultobj = 0;
17364 wxGrid *arg1 = (wxGrid *) 0 ;
17365 wxGridCellEditor *result = 0 ;
17366 void *argp1 = 0 ;
17367 int res1 = 0 ;
17368 PyObject *swig_obj[1] ;
17369
17370 if (!args) SWIG_fail;
17371 swig_obj[0] = args;
17372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17373 if (!SWIG_IsOK(res1)) {
17374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17375 }
17376 arg1 = reinterpret_cast< wxGrid * >(argp1);
17377 {
17378 PyThreadState* __tstate = wxPyBeginAllowThreads();
17379 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17380 wxPyEndAllowThreads(__tstate);
17381 if (PyErr_Occurred()) SWIG_fail;
17382 }
17383 {
17384 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17385 }
17386 return resultobj;
17387 fail:
17388 return NULL;
17389 }
17390
17391
17392 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj = 0;
17394 wxGrid *arg1 = (wxGrid *) 0 ;
17395 int arg2 ;
17396 int arg3 ;
17397 wxGridCellEditor *result = 0 ;
17398 void *argp1 = 0 ;
17399 int res1 = 0 ;
17400 int val2 ;
17401 int ecode2 = 0 ;
17402 int val3 ;
17403 int ecode3 = 0 ;
17404 PyObject * obj0 = 0 ;
17405 PyObject * obj1 = 0 ;
17406 PyObject * obj2 = 0 ;
17407 char * kwnames[] = {
17408 (char *) "self",(char *) "row",(char *) "col", NULL
17409 };
17410
17411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17413 if (!SWIG_IsOK(res1)) {
17414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17415 }
17416 arg1 = reinterpret_cast< wxGrid * >(argp1);
17417 ecode2 = SWIG_AsVal_int(obj1, &val2);
17418 if (!SWIG_IsOK(ecode2)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17420 }
17421 arg2 = static_cast< int >(val2);
17422 ecode3 = SWIG_AsVal_int(obj2, &val3);
17423 if (!SWIG_IsOK(ecode3)) {
17424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17425 }
17426 arg3 = static_cast< int >(val3);
17427 {
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17435 }
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = 0;
17444 wxGrid *arg1 = (wxGrid *) 0 ;
17445 int arg2 ;
17446 int arg3 ;
17447 wxString result;
17448 void *argp1 = 0 ;
17449 int res1 = 0 ;
17450 int val2 ;
17451 int ecode2 = 0 ;
17452 int val3 ;
17453 int ecode3 = 0 ;
17454 PyObject * obj0 = 0 ;
17455 PyObject * obj1 = 0 ;
17456 PyObject * obj2 = 0 ;
17457 char * kwnames[] = {
17458 (char *) "self",(char *) "row",(char *) "col", NULL
17459 };
17460
17461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17463 if (!SWIG_IsOK(res1)) {
17464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17465 }
17466 arg1 = reinterpret_cast< wxGrid * >(argp1);
17467 ecode2 = SWIG_AsVal_int(obj1, &val2);
17468 if (!SWIG_IsOK(ecode2)) {
17469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17470 }
17471 arg2 = static_cast< int >(val2);
17472 ecode3 = SWIG_AsVal_int(obj2, &val3);
17473 if (!SWIG_IsOK(ecode3)) {
17474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17475 }
17476 arg3 = static_cast< int >(val3);
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (arg1)->GetCellValue(arg2,arg3);
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 {
17484 #if wxUSE_UNICODE
17485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17486 #else
17487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17488 #endif
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj = 0;
17498 wxGrid *arg1 = (wxGrid *) 0 ;
17499 int arg2 ;
17500 int arg3 ;
17501 wxString *arg4 = 0 ;
17502 void *argp1 = 0 ;
17503 int res1 = 0 ;
17504 int val2 ;
17505 int ecode2 = 0 ;
17506 int val3 ;
17507 int ecode3 = 0 ;
17508 bool temp4 = false ;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 PyObject * obj2 = 0 ;
17512 PyObject * obj3 = 0 ;
17513 char * kwnames[] = {
17514 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17515 };
17516
17517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17519 if (!SWIG_IsOK(res1)) {
17520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17521 }
17522 arg1 = reinterpret_cast< wxGrid * >(argp1);
17523 ecode2 = SWIG_AsVal_int(obj1, &val2);
17524 if (!SWIG_IsOK(ecode2)) {
17525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17526 }
17527 arg2 = static_cast< int >(val2);
17528 ecode3 = SWIG_AsVal_int(obj2, &val3);
17529 if (!SWIG_IsOK(ecode3)) {
17530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17531 }
17532 arg3 = static_cast< int >(val3);
17533 {
17534 arg4 = wxString_in_helper(obj3);
17535 if (arg4 == NULL) SWIG_fail;
17536 temp4 = true;
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_Py_Void();
17545 {
17546 if (temp4)
17547 delete arg4;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp4)
17553 delete arg4;
17554 }
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxGrid *arg1 = (wxGrid *) 0 ;
17562 int arg2 ;
17563 int arg3 ;
17564 bool result;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 int val2 ;
17568 int ecode2 = 0 ;
17569 int val3 ;
17570 int ecode3 = 0 ;
17571 PyObject * obj0 = 0 ;
17572 PyObject * obj1 = 0 ;
17573 PyObject * obj2 = 0 ;
17574 char * kwnames[] = {
17575 (char *) "self",(char *) "row",(char *) "col", NULL
17576 };
17577
17578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17580 if (!SWIG_IsOK(res1)) {
17581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17582 }
17583 arg1 = reinterpret_cast< wxGrid * >(argp1);
17584 ecode2 = SWIG_AsVal_int(obj1, &val2);
17585 if (!SWIG_IsOK(ecode2)) {
17586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17587 }
17588 arg2 = static_cast< int >(val2);
17589 ecode3 = SWIG_AsVal_int(obj2, &val3);
17590 if (!SWIG_IsOK(ecode3)) {
17591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17592 }
17593 arg3 = static_cast< int >(val3);
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17597 wxPyEndAllowThreads(__tstate);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 }
17600 {
17601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17602 }
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17610 PyObject *resultobj = 0;
17611 wxGrid *arg1 = (wxGrid *) 0 ;
17612 int arg2 ;
17613 int arg3 ;
17614 bool arg4 = (bool) true ;
17615 void *argp1 = 0 ;
17616 int res1 = 0 ;
17617 int val2 ;
17618 int ecode2 = 0 ;
17619 int val3 ;
17620 int ecode3 = 0 ;
17621 bool val4 ;
17622 int ecode4 = 0 ;
17623 PyObject * obj0 = 0 ;
17624 PyObject * obj1 = 0 ;
17625 PyObject * obj2 = 0 ;
17626 PyObject * obj3 = 0 ;
17627 char * kwnames[] = {
17628 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17629 };
17630
17631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17633 if (!SWIG_IsOK(res1)) {
17634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17635 }
17636 arg1 = reinterpret_cast< wxGrid * >(argp1);
17637 ecode2 = SWIG_AsVal_int(obj1, &val2);
17638 if (!SWIG_IsOK(ecode2)) {
17639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17640 }
17641 arg2 = static_cast< int >(val2);
17642 ecode3 = SWIG_AsVal_int(obj2, &val3);
17643 if (!SWIG_IsOK(ecode3)) {
17644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17645 }
17646 arg3 = static_cast< int >(val3);
17647 if (obj3) {
17648 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17649 if (!SWIG_IsOK(ecode4)) {
17650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17651 }
17652 arg4 = static_cast< bool >(val4);
17653 }
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 (arg1)->SetReadOnly(arg2,arg3,arg4);
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 resultobj = SWIG_Py_Void();
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = 0;
17669 wxGrid *arg1 = (wxGrid *) 0 ;
17670 int arg2 ;
17671 bool arg3 = (bool) false ;
17672 void *argp1 = 0 ;
17673 int res1 = 0 ;
17674 int val2 ;
17675 int ecode2 = 0 ;
17676 bool val3 ;
17677 int ecode3 = 0 ;
17678 PyObject * obj0 = 0 ;
17679 PyObject * obj1 = 0 ;
17680 PyObject * obj2 = 0 ;
17681 char * kwnames[] = {
17682 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17683 };
17684
17685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17687 if (!SWIG_IsOK(res1)) {
17688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17689 }
17690 arg1 = reinterpret_cast< wxGrid * >(argp1);
17691 ecode2 = SWIG_AsVal_int(obj1, &val2);
17692 if (!SWIG_IsOK(ecode2)) {
17693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17694 }
17695 arg2 = static_cast< int >(val2);
17696 if (obj2) {
17697 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17698 if (!SWIG_IsOK(ecode3)) {
17699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17700 }
17701 arg3 = static_cast< bool >(val3);
17702 }
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 (arg1)->SelectRow(arg2,arg3);
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 resultobj = SWIG_Py_Void();
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17717 PyObject *resultobj = 0;
17718 wxGrid *arg1 = (wxGrid *) 0 ;
17719 int arg2 ;
17720 bool arg3 = (bool) false ;
17721 void *argp1 = 0 ;
17722 int res1 = 0 ;
17723 int val2 ;
17724 int ecode2 = 0 ;
17725 bool val3 ;
17726 int ecode3 = 0 ;
17727 PyObject * obj0 = 0 ;
17728 PyObject * obj1 = 0 ;
17729 PyObject * obj2 = 0 ;
17730 char * kwnames[] = {
17731 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17732 };
17733
17734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17736 if (!SWIG_IsOK(res1)) {
17737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17738 }
17739 arg1 = reinterpret_cast< wxGrid * >(argp1);
17740 ecode2 = SWIG_AsVal_int(obj1, &val2);
17741 if (!SWIG_IsOK(ecode2)) {
17742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17743 }
17744 arg2 = static_cast< int >(val2);
17745 if (obj2) {
17746 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17747 if (!SWIG_IsOK(ecode3)) {
17748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17749 }
17750 arg3 = static_cast< bool >(val3);
17751 }
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 (arg1)->SelectCol(arg2,arg3);
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 resultobj = SWIG_Py_Void();
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj = 0;
17767 wxGrid *arg1 = (wxGrid *) 0 ;
17768 int arg2 ;
17769 int arg3 ;
17770 int arg4 ;
17771 int arg5 ;
17772 bool arg6 = (bool) false ;
17773 void *argp1 = 0 ;
17774 int res1 = 0 ;
17775 int val2 ;
17776 int ecode2 = 0 ;
17777 int val3 ;
17778 int ecode3 = 0 ;
17779 int val4 ;
17780 int ecode4 = 0 ;
17781 int val5 ;
17782 int ecode5 = 0 ;
17783 bool val6 ;
17784 int ecode6 = 0 ;
17785 PyObject * obj0 = 0 ;
17786 PyObject * obj1 = 0 ;
17787 PyObject * obj2 = 0 ;
17788 PyObject * obj3 = 0 ;
17789 PyObject * obj4 = 0 ;
17790 PyObject * obj5 = 0 ;
17791 char * kwnames[] = {
17792 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17793 };
17794
17795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17797 if (!SWIG_IsOK(res1)) {
17798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17799 }
17800 arg1 = reinterpret_cast< wxGrid * >(argp1);
17801 ecode2 = SWIG_AsVal_int(obj1, &val2);
17802 if (!SWIG_IsOK(ecode2)) {
17803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17804 }
17805 arg2 = static_cast< int >(val2);
17806 ecode3 = SWIG_AsVal_int(obj2, &val3);
17807 if (!SWIG_IsOK(ecode3)) {
17808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17809 }
17810 arg3 = static_cast< int >(val3);
17811 ecode4 = SWIG_AsVal_int(obj3, &val4);
17812 if (!SWIG_IsOK(ecode4)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17814 }
17815 arg4 = static_cast< int >(val4);
17816 ecode5 = SWIG_AsVal_int(obj4, &val5);
17817 if (!SWIG_IsOK(ecode5)) {
17818 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17819 }
17820 arg5 = static_cast< int >(val5);
17821 if (obj5) {
17822 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17823 if (!SWIG_IsOK(ecode6)) {
17824 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17825 }
17826 arg6 = static_cast< bool >(val6);
17827 }
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 resultobj = SWIG_Py_Void();
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842 PyObject *resultobj = 0;
17843 wxGrid *arg1 = (wxGrid *) 0 ;
17844 void *argp1 = 0 ;
17845 int res1 = 0 ;
17846 PyObject *swig_obj[1] ;
17847
17848 if (!args) SWIG_fail;
17849 swig_obj[0] = args;
17850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17851 if (!SWIG_IsOK(res1)) {
17852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17853 }
17854 arg1 = reinterpret_cast< wxGrid * >(argp1);
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 (arg1)->SelectAll();
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 resultobj = SWIG_Py_Void();
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17869 PyObject *resultobj = 0;
17870 wxGrid *arg1 = (wxGrid *) 0 ;
17871 bool result;
17872 void *argp1 = 0 ;
17873 int res1 = 0 ;
17874 PyObject *swig_obj[1] ;
17875
17876 if (!args) SWIG_fail;
17877 swig_obj[0] = args;
17878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17879 if (!SWIG_IsOK(res1)) {
17880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17881 }
17882 arg1 = reinterpret_cast< wxGrid * >(argp1);
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 result = (bool)(arg1)->IsSelection();
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17899 PyObject *resultobj = 0;
17900 wxGrid *arg1 = (wxGrid *) 0 ;
17901 void *argp1 = 0 ;
17902 int res1 = 0 ;
17903 PyObject *swig_obj[1] ;
17904
17905 if (!args) SWIG_fail;
17906 swig_obj[0] = args;
17907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17908 if (!SWIG_IsOK(res1)) {
17909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17910 }
17911 arg1 = reinterpret_cast< wxGrid * >(argp1);
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 (arg1)->ClearSelection();
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 resultobj = SWIG_Py_Void();
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj = 0;
17927 wxGrid *arg1 = (wxGrid *) 0 ;
17928 int arg2 ;
17929 int arg3 ;
17930 bool result;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 int val2 ;
17934 int ecode2 = 0 ;
17935 int val3 ;
17936 int ecode3 = 0 ;
17937 PyObject * obj0 = 0 ;
17938 PyObject * obj1 = 0 ;
17939 PyObject * obj2 = 0 ;
17940 char * kwnames[] = {
17941 (char *) "self",(char *) "row",(char *) "col", NULL
17942 };
17943
17944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17946 if (!SWIG_IsOK(res1)) {
17947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17948 }
17949 arg1 = reinterpret_cast< wxGrid * >(argp1);
17950 ecode2 = SWIG_AsVal_int(obj1, &val2);
17951 if (!SWIG_IsOK(ecode2)) {
17952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17953 }
17954 arg2 = static_cast< int >(val2);
17955 ecode3 = SWIG_AsVal_int(obj2, &val3);
17956 if (!SWIG_IsOK(ecode3)) {
17957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17958 }
17959 arg3 = static_cast< int >(val3);
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 {
17967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17968 }
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxGrid *arg1 = (wxGrid *) 0 ;
17978 wxGridCellCoordsArray result;
17979 void *argp1 = 0 ;
17980 int res1 = 0 ;
17981 PyObject *swig_obj[1] ;
17982
17983 if (!args) SWIG_fail;
17984 swig_obj[0] = args;
17985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17986 if (!SWIG_IsOK(res1)) {
17987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17988 }
17989 arg1 = reinterpret_cast< wxGrid * >(argp1);
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = ((wxGrid const *)arg1)->GetSelectedCells();
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 {
17997 resultobj = wxGridCellCoordsArray_helper(result);
17998 }
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18006 PyObject *resultobj = 0;
18007 wxGrid *arg1 = (wxGrid *) 0 ;
18008 wxGridCellCoordsArray result;
18009 void *argp1 = 0 ;
18010 int res1 = 0 ;
18011 PyObject *swig_obj[1] ;
18012
18013 if (!args) SWIG_fail;
18014 swig_obj[0] = args;
18015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18016 if (!SWIG_IsOK(res1)) {
18017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18018 }
18019 arg1 = reinterpret_cast< wxGrid * >(argp1);
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 {
18027 resultobj = wxGridCellCoordsArray_helper(result);
18028 }
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxGrid *arg1 = (wxGrid *) 0 ;
18038 wxGridCellCoordsArray result;
18039 void *argp1 = 0 ;
18040 int res1 = 0 ;
18041 PyObject *swig_obj[1] ;
18042
18043 if (!args) SWIG_fail;
18044 swig_obj[0] = args;
18045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18046 if (!SWIG_IsOK(res1)) {
18047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18048 }
18049 arg1 = reinterpret_cast< wxGrid * >(argp1);
18050 {
18051 PyThreadState* __tstate = wxPyBeginAllowThreads();
18052 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 {
18057 resultobj = wxGridCellCoordsArray_helper(result);
18058 }
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18066 PyObject *resultobj = 0;
18067 wxGrid *arg1 = (wxGrid *) 0 ;
18068 wxArrayInt result;
18069 void *argp1 = 0 ;
18070 int res1 = 0 ;
18071 PyObject *swig_obj[1] ;
18072
18073 if (!args) SWIG_fail;
18074 swig_obj[0] = args;
18075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18076 if (!SWIG_IsOK(res1)) {
18077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18078 }
18079 arg1 = reinterpret_cast< wxGrid * >(argp1);
18080 {
18081 PyThreadState* __tstate = wxPyBeginAllowThreads();
18082 result = ((wxGrid const *)arg1)->GetSelectedRows();
18083 wxPyEndAllowThreads(__tstate);
18084 if (PyErr_Occurred()) SWIG_fail;
18085 }
18086 {
18087 resultobj = wxArrayInt2PyList_helper(result);
18088 }
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096 PyObject *resultobj = 0;
18097 wxGrid *arg1 = (wxGrid *) 0 ;
18098 wxArrayInt result;
18099 void *argp1 = 0 ;
18100 int res1 = 0 ;
18101 PyObject *swig_obj[1] ;
18102
18103 if (!args) SWIG_fail;
18104 swig_obj[0] = args;
18105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18108 }
18109 arg1 = reinterpret_cast< wxGrid * >(argp1);
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = ((wxGrid const *)arg1)->GetSelectedCols();
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 {
18117 resultobj = wxArrayInt2PyList_helper(result);
18118 }
18119 return resultobj;
18120 fail:
18121 return NULL;
18122 }
18123
18124
18125 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18126 PyObject *resultobj = 0;
18127 wxGrid *arg1 = (wxGrid *) 0 ;
18128 int arg2 ;
18129 void *argp1 = 0 ;
18130 int res1 = 0 ;
18131 int val2 ;
18132 int ecode2 = 0 ;
18133 PyObject * obj0 = 0 ;
18134 PyObject * obj1 = 0 ;
18135 char * kwnames[] = {
18136 (char *) "self",(char *) "row", NULL
18137 };
18138
18139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18141 if (!SWIG_IsOK(res1)) {
18142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18143 }
18144 arg1 = reinterpret_cast< wxGrid * >(argp1);
18145 ecode2 = SWIG_AsVal_int(obj1, &val2);
18146 if (!SWIG_IsOK(ecode2)) {
18147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18148 }
18149 arg2 = static_cast< int >(val2);
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 (arg1)->DeselectRow(arg2);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = SWIG_Py_Void();
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj = 0;
18165 wxGrid *arg1 = (wxGrid *) 0 ;
18166 int arg2 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 int val2 ;
18170 int ecode2 = 0 ;
18171 PyObject * obj0 = 0 ;
18172 PyObject * obj1 = 0 ;
18173 char * kwnames[] = {
18174 (char *) "self",(char *) "col", NULL
18175 };
18176
18177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18179 if (!SWIG_IsOK(res1)) {
18180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18181 }
18182 arg1 = reinterpret_cast< wxGrid * >(argp1);
18183 ecode2 = SWIG_AsVal_int(obj1, &val2);
18184 if (!SWIG_IsOK(ecode2)) {
18185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18186 }
18187 arg2 = static_cast< int >(val2);
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 (arg1)->DeselectCol(arg2);
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = SWIG_Py_Void();
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj = 0;
18203 wxGrid *arg1 = (wxGrid *) 0 ;
18204 int arg2 ;
18205 int arg3 ;
18206 void *argp1 = 0 ;
18207 int res1 = 0 ;
18208 int val2 ;
18209 int ecode2 = 0 ;
18210 int val3 ;
18211 int ecode3 = 0 ;
18212 PyObject * obj0 = 0 ;
18213 PyObject * obj1 = 0 ;
18214 PyObject * obj2 = 0 ;
18215 char * kwnames[] = {
18216 (char *) "self",(char *) "row",(char *) "col", NULL
18217 };
18218
18219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18221 if (!SWIG_IsOK(res1)) {
18222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18223 }
18224 arg1 = reinterpret_cast< wxGrid * >(argp1);
18225 ecode2 = SWIG_AsVal_int(obj1, &val2);
18226 if (!SWIG_IsOK(ecode2)) {
18227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18228 }
18229 arg2 = static_cast< int >(val2);
18230 ecode3 = SWIG_AsVal_int(obj2, &val3);
18231 if (!SWIG_IsOK(ecode3)) {
18232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18233 }
18234 arg3 = static_cast< int >(val3);
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 (arg1)->DeselectCell(arg2,arg3);
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 resultobj = SWIG_Py_Void();
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj = 0;
18250 wxGrid *arg1 = (wxGrid *) 0 ;
18251 wxGridCellCoords *arg2 = 0 ;
18252 wxGridCellCoords *arg3 = 0 ;
18253 wxRect result;
18254 void *argp1 = 0 ;
18255 int res1 = 0 ;
18256 wxGridCellCoords temp2 ;
18257 wxGridCellCoords temp3 ;
18258 PyObject * obj0 = 0 ;
18259 PyObject * obj1 = 0 ;
18260 PyObject * obj2 = 0 ;
18261 char * kwnames[] = {
18262 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18263 };
18264
18265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18267 if (!SWIG_IsOK(res1)) {
18268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18269 }
18270 arg1 = reinterpret_cast< wxGrid * >(argp1);
18271 {
18272 arg2 = &temp2;
18273 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18274 }
18275 {
18276 arg3 = &temp3;
18277 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18278 }
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 PyObject *resultobj = 0;
18294 wxGrid *arg1 = (wxGrid *) 0 ;
18295 wxColour result;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 PyObject *swig_obj[1] ;
18299
18300 if (!args) SWIG_fail;
18301 swig_obj[0] = args;
18302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18305 }
18306 arg1 = reinterpret_cast< wxGrid * >(argp1);
18307 {
18308 PyThreadState* __tstate = wxPyBeginAllowThreads();
18309 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18310 wxPyEndAllowThreads(__tstate);
18311 if (PyErr_Occurred()) SWIG_fail;
18312 }
18313 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18321 PyObject *resultobj = 0;
18322 wxGrid *arg1 = (wxGrid *) 0 ;
18323 wxColour result;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 PyObject *swig_obj[1] ;
18327
18328 if (!args) SWIG_fail;
18329 swig_obj[0] = args;
18330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18331 if (!SWIG_IsOK(res1)) {
18332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18333 }
18334 arg1 = reinterpret_cast< wxGrid * >(argp1);
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18338 wxPyEndAllowThreads(__tstate);
18339 if (PyErr_Occurred()) SWIG_fail;
18340 }
18341 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18342 return resultobj;
18343 fail:
18344 return NULL;
18345 }
18346
18347
18348 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18349 PyObject *resultobj = 0;
18350 wxGrid *arg1 = (wxGrid *) 0 ;
18351 wxColour *arg2 = 0 ;
18352 void *argp1 = 0 ;
18353 int res1 = 0 ;
18354 wxColour temp2 ;
18355 PyObject * obj0 = 0 ;
18356 PyObject * obj1 = 0 ;
18357 char * kwnames[] = {
18358 (char *) "self",(char *) "c", NULL
18359 };
18360
18361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18363 if (!SWIG_IsOK(res1)) {
18364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18365 }
18366 arg1 = reinterpret_cast< wxGrid * >(argp1);
18367 {
18368 arg2 = &temp2;
18369 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18370 }
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj = 0;
18386 wxGrid *arg1 = (wxGrid *) 0 ;
18387 wxColour *arg2 = 0 ;
18388 void *argp1 = 0 ;
18389 int res1 = 0 ;
18390 wxColour temp2 ;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 char * kwnames[] = {
18394 (char *) "self",(char *) "c", NULL
18395 };
18396
18397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18399 if (!SWIG_IsOK(res1)) {
18400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18401 }
18402 arg1 = reinterpret_cast< wxGrid * >(argp1);
18403 {
18404 arg2 = &temp2;
18405 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18406 }
18407 {
18408 PyThreadState* __tstate = wxPyBeginAllowThreads();
18409 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 resultobj = SWIG_Py_Void();
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj = 0;
18422 wxGrid *arg1 = (wxGrid *) 0 ;
18423 wxString *arg2 = 0 ;
18424 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18425 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18426 void *argp1 = 0 ;
18427 int res1 = 0 ;
18428 bool temp2 = false ;
18429 void *argp3 = 0 ;
18430 int res3 = 0 ;
18431 void *argp4 = 0 ;
18432 int res4 = 0 ;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 PyObject * obj2 = 0 ;
18436 PyObject * obj3 = 0 ;
18437 char * kwnames[] = {
18438 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18439 };
18440
18441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18443 if (!SWIG_IsOK(res1)) {
18444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18445 }
18446 arg1 = reinterpret_cast< wxGrid * >(argp1);
18447 {
18448 arg2 = wxString_in_helper(obj1);
18449 if (arg2 == NULL) SWIG_fail;
18450 temp2 = true;
18451 }
18452 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18453 if (!SWIG_IsOK(res3)) {
18454 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18455 }
18456 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18457 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18458 if (!SWIG_IsOK(res4)) {
18459 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18460 }
18461 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_Py_Void();
18469 {
18470 if (temp2)
18471 delete arg2;
18472 }
18473 return resultobj;
18474 fail:
18475 {
18476 if (temp2)
18477 delete arg2;
18478 }
18479 return NULL;
18480 }
18481
18482
18483 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18484 PyObject *resultobj = 0;
18485 wxGrid *arg1 = (wxGrid *) 0 ;
18486 int arg2 ;
18487 int arg3 ;
18488 wxGridCellEditor *result = 0 ;
18489 void *argp1 = 0 ;
18490 int res1 = 0 ;
18491 int val2 ;
18492 int ecode2 = 0 ;
18493 int val3 ;
18494 int ecode3 = 0 ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 PyObject * obj2 = 0 ;
18498 char * kwnames[] = {
18499 (char *) "self",(char *) "row",(char *) "col", NULL
18500 };
18501
18502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18506 }
18507 arg1 = reinterpret_cast< wxGrid * >(argp1);
18508 ecode2 = SWIG_AsVal_int(obj1, &val2);
18509 if (!SWIG_IsOK(ecode2)) {
18510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18511 }
18512 arg2 = static_cast< int >(val2);
18513 ecode3 = SWIG_AsVal_int(obj2, &val3);
18514 if (!SWIG_IsOK(ecode3)) {
18515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18516 }
18517 arg3 = static_cast< int >(val3);
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 {
18525 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18526 }
18527 return resultobj;
18528 fail:
18529 return NULL;
18530 }
18531
18532
18533 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18534 PyObject *resultobj = 0;
18535 wxGrid *arg1 = (wxGrid *) 0 ;
18536 int arg2 ;
18537 int arg3 ;
18538 wxGridCellRenderer *result = 0 ;
18539 void *argp1 = 0 ;
18540 int res1 = 0 ;
18541 int val2 ;
18542 int ecode2 = 0 ;
18543 int val3 ;
18544 int ecode3 = 0 ;
18545 PyObject * obj0 = 0 ;
18546 PyObject * obj1 = 0 ;
18547 PyObject * obj2 = 0 ;
18548 char * kwnames[] = {
18549 (char *) "self",(char *) "row",(char *) "col", NULL
18550 };
18551
18552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18554 if (!SWIG_IsOK(res1)) {
18555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18556 }
18557 arg1 = reinterpret_cast< wxGrid * >(argp1);
18558 ecode2 = SWIG_AsVal_int(obj1, &val2);
18559 if (!SWIG_IsOK(ecode2)) {
18560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18561 }
18562 arg2 = static_cast< int >(val2);
18563 ecode3 = SWIG_AsVal_int(obj2, &val3);
18564 if (!SWIG_IsOK(ecode3)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18566 }
18567 arg3 = static_cast< int >(val3);
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18571 wxPyEndAllowThreads(__tstate);
18572 if (PyErr_Occurred()) SWIG_fail;
18573 }
18574 {
18575 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18576 }
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj = 0;
18585 wxGrid *arg1 = (wxGrid *) 0 ;
18586 wxString *arg2 = 0 ;
18587 wxGridCellEditor *result = 0 ;
18588 void *argp1 = 0 ;
18589 int res1 = 0 ;
18590 bool temp2 = false ;
18591 PyObject * obj0 = 0 ;
18592 PyObject * obj1 = 0 ;
18593 char * kwnames[] = {
18594 (char *) "self",(char *) "typeName", NULL
18595 };
18596
18597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18599 if (!SWIG_IsOK(res1)) {
18600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18601 }
18602 arg1 = reinterpret_cast< wxGrid * >(argp1);
18603 {
18604 arg2 = wxString_in_helper(obj1);
18605 if (arg2 == NULL) SWIG_fail;
18606 temp2 = true;
18607 }
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 {
18615 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18616 }
18617 {
18618 if (temp2)
18619 delete arg2;
18620 }
18621 return resultobj;
18622 fail:
18623 {
18624 if (temp2)
18625 delete arg2;
18626 }
18627 return NULL;
18628 }
18629
18630
18631 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj = 0;
18633 wxGrid *arg1 = (wxGrid *) 0 ;
18634 wxString *arg2 = 0 ;
18635 wxGridCellRenderer *result = 0 ;
18636 void *argp1 = 0 ;
18637 int res1 = 0 ;
18638 bool temp2 = false ;
18639 PyObject * obj0 = 0 ;
18640 PyObject * obj1 = 0 ;
18641 char * kwnames[] = {
18642 (char *) "self",(char *) "typeName", NULL
18643 };
18644
18645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18647 if (!SWIG_IsOK(res1)) {
18648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18649 }
18650 arg1 = reinterpret_cast< wxGrid * >(argp1);
18651 {
18652 arg2 = wxString_in_helper(obj1);
18653 if (arg2 == NULL) SWIG_fail;
18654 temp2 = true;
18655 }
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 {
18663 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18664 }
18665 {
18666 if (temp2)
18667 delete arg2;
18668 }
18669 return resultobj;
18670 fail:
18671 {
18672 if (temp2)
18673 delete arg2;
18674 }
18675 return NULL;
18676 }
18677
18678
18679 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18680 PyObject *resultobj = 0;
18681 wxGrid *arg1 = (wxGrid *) 0 ;
18682 int arg2 ;
18683 int arg3 ;
18684 void *argp1 = 0 ;
18685 int res1 = 0 ;
18686 int val2 ;
18687 int ecode2 = 0 ;
18688 int val3 ;
18689 int ecode3 = 0 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 PyObject * obj2 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18699 if (!SWIG_IsOK(res1)) {
18700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18701 }
18702 arg1 = reinterpret_cast< wxGrid * >(argp1);
18703 ecode2 = SWIG_AsVal_int(obj1, &val2);
18704 if (!SWIG_IsOK(ecode2)) {
18705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18706 }
18707 arg2 = static_cast< int >(val2);
18708 ecode3 = SWIG_AsVal_int(obj2, &val3);
18709 if (!SWIG_IsOK(ecode3)) {
18710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18711 }
18712 arg3 = static_cast< int >(val3);
18713 {
18714 PyThreadState* __tstate = wxPyBeginAllowThreads();
18715 (arg1)->SetMargins(arg2,arg3);
18716 wxPyEndAllowThreads(__tstate);
18717 if (PyErr_Occurred()) SWIG_fail;
18718 }
18719 resultobj = SWIG_Py_Void();
18720 return resultobj;
18721 fail:
18722 return NULL;
18723 }
18724
18725
18726 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18727 PyObject *resultobj = 0;
18728 wxGrid *arg1 = (wxGrid *) 0 ;
18729 wxWindow *result = 0 ;
18730 void *argp1 = 0 ;
18731 int res1 = 0 ;
18732 PyObject *swig_obj[1] ;
18733
18734 if (!args) SWIG_fail;
18735 swig_obj[0] = args;
18736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18737 if (!SWIG_IsOK(res1)) {
18738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18739 }
18740 arg1 = reinterpret_cast< wxGrid * >(argp1);
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 result = (wxWindow *)(arg1)->GetGridWindow();
18744 wxPyEndAllowThreads(__tstate);
18745 if (PyErr_Occurred()) SWIG_fail;
18746 }
18747 {
18748 resultobj = wxPyMake_wxObject(result, 0);
18749 }
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18757 PyObject *resultobj = 0;
18758 wxGrid *arg1 = (wxGrid *) 0 ;
18759 wxWindow *result = 0 ;
18760 void *argp1 = 0 ;
18761 int res1 = 0 ;
18762 PyObject *swig_obj[1] ;
18763
18764 if (!args) SWIG_fail;
18765 swig_obj[0] = args;
18766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18767 if (!SWIG_IsOK(res1)) {
18768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18769 }
18770 arg1 = reinterpret_cast< wxGrid * >(argp1);
18771 {
18772 PyThreadState* __tstate = wxPyBeginAllowThreads();
18773 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18774 wxPyEndAllowThreads(__tstate);
18775 if (PyErr_Occurred()) SWIG_fail;
18776 }
18777 {
18778 resultobj = wxPyMake_wxObject(result, 0);
18779 }
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18787 PyObject *resultobj = 0;
18788 wxGrid *arg1 = (wxGrid *) 0 ;
18789 wxWindow *result = 0 ;
18790 void *argp1 = 0 ;
18791 int res1 = 0 ;
18792 PyObject *swig_obj[1] ;
18793
18794 if (!args) SWIG_fail;
18795 swig_obj[0] = args;
18796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18797 if (!SWIG_IsOK(res1)) {
18798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18799 }
18800 arg1 = reinterpret_cast< wxGrid * >(argp1);
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18804 wxPyEndAllowThreads(__tstate);
18805 if (PyErr_Occurred()) SWIG_fail;
18806 }
18807 {
18808 resultobj = wxPyMake_wxObject(result, 0);
18809 }
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18817 PyObject *resultobj = 0;
18818 wxGrid *arg1 = (wxGrid *) 0 ;
18819 wxWindow *result = 0 ;
18820 void *argp1 = 0 ;
18821 int res1 = 0 ;
18822 PyObject *swig_obj[1] ;
18823
18824 if (!args) SWIG_fail;
18825 swig_obj[0] = args;
18826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18827 if (!SWIG_IsOK(res1)) {
18828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18829 }
18830 arg1 = reinterpret_cast< wxGrid * >(argp1);
18831 {
18832 PyThreadState* __tstate = wxPyBeginAllowThreads();
18833 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18834 wxPyEndAllowThreads(__tstate);
18835 if (PyErr_Occurred()) SWIG_fail;
18836 }
18837 {
18838 resultobj = wxPyMake_wxObject(result, 0);
18839 }
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj = 0;
18848 wxGrid *arg1 = (wxGrid *) 0 ;
18849 int arg2 ;
18850 void *argp1 = 0 ;
18851 int res1 = 0 ;
18852 int val2 ;
18853 int ecode2 = 0 ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 char * kwnames[] = {
18857 (char *) "self",(char *) "x", NULL
18858 };
18859
18860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18862 if (!SWIG_IsOK(res1)) {
18863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18864 }
18865 arg1 = reinterpret_cast< wxGrid * >(argp1);
18866 ecode2 = SWIG_AsVal_int(obj1, &val2);
18867 if (!SWIG_IsOK(ecode2)) {
18868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18869 }
18870 arg2 = static_cast< int >(val2);
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 (arg1)->SetScrollLineX(arg2);
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 resultobj = SWIG_Py_Void();
18878 return resultobj;
18879 fail:
18880 return NULL;
18881 }
18882
18883
18884 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18885 PyObject *resultobj = 0;
18886 wxGrid *arg1 = (wxGrid *) 0 ;
18887 int arg2 ;
18888 void *argp1 = 0 ;
18889 int res1 = 0 ;
18890 int val2 ;
18891 int ecode2 = 0 ;
18892 PyObject * obj0 = 0 ;
18893 PyObject * obj1 = 0 ;
18894 char * kwnames[] = {
18895 (char *) "self",(char *) "y", NULL
18896 };
18897
18898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18900 if (!SWIG_IsOK(res1)) {
18901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18902 }
18903 arg1 = reinterpret_cast< wxGrid * >(argp1);
18904 ecode2 = SWIG_AsVal_int(obj1, &val2);
18905 if (!SWIG_IsOK(ecode2)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18907 }
18908 arg2 = static_cast< int >(val2);
18909 {
18910 PyThreadState* __tstate = wxPyBeginAllowThreads();
18911 (arg1)->SetScrollLineY(arg2);
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 resultobj = SWIG_Py_Void();
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18923 PyObject *resultobj = 0;
18924 wxGrid *arg1 = (wxGrid *) 0 ;
18925 int result;
18926 void *argp1 = 0 ;
18927 int res1 = 0 ;
18928 PyObject *swig_obj[1] ;
18929
18930 if (!args) SWIG_fail;
18931 swig_obj[0] = args;
18932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18935 }
18936 arg1 = reinterpret_cast< wxGrid * >(argp1);
18937 {
18938 PyThreadState* __tstate = wxPyBeginAllowThreads();
18939 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18940 wxPyEndAllowThreads(__tstate);
18941 if (PyErr_Occurred()) SWIG_fail;
18942 }
18943 resultobj = SWIG_From_int(static_cast< int >(result));
18944 return resultobj;
18945 fail:
18946 return NULL;
18947 }
18948
18949
18950 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18951 PyObject *resultobj = 0;
18952 wxGrid *arg1 = (wxGrid *) 0 ;
18953 int result;
18954 void *argp1 = 0 ;
18955 int res1 = 0 ;
18956 PyObject *swig_obj[1] ;
18957
18958 if (!args) SWIG_fail;
18959 swig_obj[0] = args;
18960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18961 if (!SWIG_IsOK(res1)) {
18962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18963 }
18964 arg1 = reinterpret_cast< wxGrid * >(argp1);
18965 {
18966 PyThreadState* __tstate = wxPyBeginAllowThreads();
18967 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 resultobj = SWIG_From_int(static_cast< int >(result));
18972 return resultobj;
18973 fail:
18974 return NULL;
18975 }
18976
18977
18978 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18979 PyObject *resultobj = 0;
18980 wxGrid *arg1 = (wxGrid *) 0 ;
18981 int arg2 ;
18982 int result;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 int val2 ;
18986 int ecode2 = 0 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char * kwnames[] = {
18990 (char *) "self",(char *) "x", NULL
18991 };
18992
18993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18995 if (!SWIG_IsOK(res1)) {
18996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18997 }
18998 arg1 = reinterpret_cast< wxGrid * >(argp1);
18999 ecode2 = SWIG_AsVal_int(obj1, &val2);
19000 if (!SWIG_IsOK(ecode2)) {
19001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
19002 }
19003 arg2 = static_cast< int >(val2);
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 resultobj = SWIG_From_int(static_cast< int >(result));
19011 return resultobj;
19012 fail:
19013 return NULL;
19014 }
19015
19016
19017 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19018 PyObject *resultobj = 0;
19019 wxGrid *arg1 = (wxGrid *) 0 ;
19020 int arg2 ;
19021 int result;
19022 void *argp1 = 0 ;
19023 int res1 = 0 ;
19024 int val2 ;
19025 int ecode2 = 0 ;
19026 PyObject * obj0 = 0 ;
19027 PyObject * obj1 = 0 ;
19028 char * kwnames[] = {
19029 (char *) "self",(char *) "y", NULL
19030 };
19031
19032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19034 if (!SWIG_IsOK(res1)) {
19035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19036 }
19037 arg1 = reinterpret_cast< wxGrid * >(argp1);
19038 ecode2 = SWIG_AsVal_int(obj1, &val2);
19039 if (!SWIG_IsOK(ecode2)) {
19040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19041 }
19042 arg2 = static_cast< int >(val2);
19043 {
19044 PyThreadState* __tstate = wxPyBeginAllowThreads();
19045 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19046 wxPyEndAllowThreads(__tstate);
19047 if (PyErr_Occurred()) SWIG_fail;
19048 }
19049 resultobj = SWIG_From_int(static_cast< int >(result));
19050 return resultobj;
19051 fail:
19052 return NULL;
19053 }
19054
19055
19056 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19057 PyObject *resultobj = 0;
19058 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19059 SwigValueWrapper<wxVisualAttributes > result;
19060 int val1 ;
19061 int ecode1 = 0 ;
19062 PyObject * obj0 = 0 ;
19063 char * kwnames[] = {
19064 (char *) "variant", NULL
19065 };
19066
19067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19068 if (obj0) {
19069 ecode1 = SWIG_AsVal_int(obj0, &val1);
19070 if (!SWIG_IsOK(ecode1)) {
19071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19072 }
19073 arg1 = static_cast< wxWindowVariant >(val1);
19074 }
19075 {
19076 if (!wxPyCheckForApp()) SWIG_fail;
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 result = wxGrid::GetClassDefaultAttributes(arg1);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19090 PyObject *obj;
19091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19092 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19093 return SWIG_Py_Void();
19094 }
19095
19096 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19097 return SWIG_Python_InitShadowInstance(args);
19098 }
19099
19100 SWIGINTERN PyObject *_wrap_new_GridUpdateLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj = 0;
19102 wxGrid *arg1 = (wxGrid *) NULL ;
19103 wxGridUpdateLocker *result = 0 ;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 PyObject * obj0 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "grid", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridUpdateLocker",kwnames,&obj0)) SWIG_fail;
19112 if (obj0) {
19113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridUpdateLocker" "', expected argument " "1"" of type '" "wxGrid *""'");
19116 }
19117 arg1 = reinterpret_cast< wxGrid * >(argp1);
19118 }
19119 {
19120 PyThreadState* __tstate = wxPyBeginAllowThreads();
19121 result = (wxGridUpdateLocker *)new wxGridUpdateLocker(arg1);
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridUpdateLocker, SWIG_POINTER_NEW | 0 );
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 SWIGINTERN PyObject *_wrap_delete_GridUpdateLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19133 PyObject *resultobj = 0;
19134 wxGridUpdateLocker *arg1 = (wxGridUpdateLocker *) 0 ;
19135 void *argp1 = 0 ;
19136 int res1 = 0 ;
19137 PyObject *swig_obj[1] ;
19138
19139 if (!args) SWIG_fail;
19140 swig_obj[0] = args;
19141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridUpdateLocker, SWIG_POINTER_DISOWN | 0 );
19142 if (!SWIG_IsOK(res1)) {
19143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridUpdateLocker" "', expected argument " "1"" of type '" "wxGridUpdateLocker *""'");
19144 }
19145 arg1 = reinterpret_cast< wxGridUpdateLocker * >(argp1);
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 delete arg1;
19149
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 resultobj = SWIG_Py_Void();
19154 return resultobj;
19155 fail:
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_GridUpdateLocker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19161 PyObject *resultobj = 0;
19162 wxGridUpdateLocker *arg1 = (wxGridUpdateLocker *) 0 ;
19163 wxGrid *arg2 = (wxGrid *) 0 ;
19164 void *argp1 = 0 ;
19165 int res1 = 0 ;
19166 void *argp2 = 0 ;
19167 int res2 = 0 ;
19168 PyObject * obj0 = 0 ;
19169 PyObject * obj1 = 0 ;
19170 char * kwnames[] = {
19171 (char *) "self",(char *) "grid", NULL
19172 };
19173
19174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridUpdateLocker_Create",kwnames,&obj0,&obj1)) SWIG_fail;
19175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridUpdateLocker, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridUpdateLocker_Create" "', expected argument " "1"" of type '" "wxGridUpdateLocker *""'");
19178 }
19179 arg1 = reinterpret_cast< wxGridUpdateLocker * >(argp1);
19180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
19181 if (!SWIG_IsOK(res2)) {
19182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridUpdateLocker_Create" "', expected argument " "2"" of type '" "wxGrid *""'");
19183 }
19184 arg2 = reinterpret_cast< wxGrid * >(argp2);
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 (arg1)->Create(arg2);
19188 wxPyEndAllowThreads(__tstate);
19189 if (PyErr_Occurred()) SWIG_fail;
19190 }
19191 resultobj = SWIG_Py_Void();
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 SWIGINTERN PyObject *GridUpdateLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19199 PyObject *obj;
19200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19201 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridUpdateLocker, SWIG_NewClientData(obj));
19202 return SWIG_Py_Void();
19203 }
19204
19205 SWIGINTERN PyObject *GridUpdateLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19206 return SWIG_Python_InitShadowInstance(args);
19207 }
19208
19209 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj = 0;
19211 int arg1 ;
19212 wxEventType arg2 ;
19213 wxGrid *arg3 = (wxGrid *) 0 ;
19214 int arg4 = (int) -1 ;
19215 int arg5 = (int) -1 ;
19216 int arg6 = (int) -1 ;
19217 int arg7 = (int) -1 ;
19218 bool arg8 = (bool) true ;
19219 bool arg9 = (bool) false ;
19220 bool arg10 = (bool) false ;
19221 bool arg11 = (bool) false ;
19222 bool arg12 = (bool) false ;
19223 wxGridEvent *result = 0 ;
19224 int val1 ;
19225 int ecode1 = 0 ;
19226 int val2 ;
19227 int ecode2 = 0 ;
19228 void *argp3 = 0 ;
19229 int res3 = 0 ;
19230 int val4 ;
19231 int ecode4 = 0 ;
19232 int val5 ;
19233 int ecode5 = 0 ;
19234 int val6 ;
19235 int ecode6 = 0 ;
19236 int val7 ;
19237 int ecode7 = 0 ;
19238 bool val8 ;
19239 int ecode8 = 0 ;
19240 bool val9 ;
19241 int ecode9 = 0 ;
19242 bool val10 ;
19243 int ecode10 = 0 ;
19244 bool val11 ;
19245 int ecode11 = 0 ;
19246 bool val12 ;
19247 int ecode12 = 0 ;
19248 PyObject * obj0 = 0 ;
19249 PyObject * obj1 = 0 ;
19250 PyObject * obj2 = 0 ;
19251 PyObject * obj3 = 0 ;
19252 PyObject * obj4 = 0 ;
19253 PyObject * obj5 = 0 ;
19254 PyObject * obj6 = 0 ;
19255 PyObject * obj7 = 0 ;
19256 PyObject * obj8 = 0 ;
19257 PyObject * obj9 = 0 ;
19258 PyObject * obj10 = 0 ;
19259 PyObject * obj11 = 0 ;
19260 char * kwnames[] = {
19261 (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
19262 };
19263
19264 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;
19265 ecode1 = SWIG_AsVal_int(obj0, &val1);
19266 if (!SWIG_IsOK(ecode1)) {
19267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19268 }
19269 arg1 = static_cast< int >(val1);
19270 ecode2 = SWIG_AsVal_int(obj1, &val2);
19271 if (!SWIG_IsOK(ecode2)) {
19272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19273 }
19274 arg2 = static_cast< wxEventType >(val2);
19275 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19276 if (!SWIG_IsOK(res3)) {
19277 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19278 }
19279 arg3 = reinterpret_cast< wxGrid * >(argp3);
19280 if (obj3) {
19281 ecode4 = SWIG_AsVal_int(obj3, &val4);
19282 if (!SWIG_IsOK(ecode4)) {
19283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19284 }
19285 arg4 = static_cast< int >(val4);
19286 }
19287 if (obj4) {
19288 ecode5 = SWIG_AsVal_int(obj4, &val5);
19289 if (!SWIG_IsOK(ecode5)) {
19290 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19291 }
19292 arg5 = static_cast< int >(val5);
19293 }
19294 if (obj5) {
19295 ecode6 = SWIG_AsVal_int(obj5, &val6);
19296 if (!SWIG_IsOK(ecode6)) {
19297 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19298 }
19299 arg6 = static_cast< int >(val6);
19300 }
19301 if (obj6) {
19302 ecode7 = SWIG_AsVal_int(obj6, &val7);
19303 if (!SWIG_IsOK(ecode7)) {
19304 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19305 }
19306 arg7 = static_cast< int >(val7);
19307 }
19308 if (obj7) {
19309 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19310 if (!SWIG_IsOK(ecode8)) {
19311 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19312 }
19313 arg8 = static_cast< bool >(val8);
19314 }
19315 if (obj8) {
19316 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19317 if (!SWIG_IsOK(ecode9)) {
19318 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19319 }
19320 arg9 = static_cast< bool >(val9);
19321 }
19322 if (obj9) {
19323 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19324 if (!SWIG_IsOK(ecode10)) {
19325 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19326 }
19327 arg10 = static_cast< bool >(val10);
19328 }
19329 if (obj10) {
19330 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19331 if (!SWIG_IsOK(ecode11)) {
19332 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19333 }
19334 arg11 = static_cast< bool >(val11);
19335 }
19336 if (obj11) {
19337 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19338 if (!SWIG_IsOK(ecode12)) {
19339 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19340 }
19341 arg12 = static_cast< bool >(val12);
19342 }
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19350 return resultobj;
19351 fail:
19352 return NULL;
19353 }
19354
19355
19356 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19357 PyObject *resultobj = 0;
19358 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19359 int 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_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19369 }
19370 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (int)(arg1)->GetRow();
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 resultobj = SWIG_From_int(static_cast< int >(result));
19378 return resultobj;
19379 fail:
19380 return NULL;
19381 }
19382
19383
19384 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19385 PyObject *resultobj = 0;
19386 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19387 int result;
19388 void *argp1 = 0 ;
19389 int res1 = 0 ;
19390 PyObject *swig_obj[1] ;
19391
19392 if (!args) SWIG_fail;
19393 swig_obj[0] = args;
19394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19395 if (!SWIG_IsOK(res1)) {
19396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19397 }
19398 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 result = (int)(arg1)->GetCol();
19402 wxPyEndAllowThreads(__tstate);
19403 if (PyErr_Occurred()) SWIG_fail;
19404 }
19405 resultobj = SWIG_From_int(static_cast< int >(result));
19406 return resultobj;
19407 fail:
19408 return NULL;
19409 }
19410
19411
19412 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19413 PyObject *resultobj = 0;
19414 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19415 wxPoint result;
19416 void *argp1 = 0 ;
19417 int res1 = 0 ;
19418 PyObject *swig_obj[1] ;
19419
19420 if (!args) SWIG_fail;
19421 swig_obj[0] = args;
19422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19423 if (!SWIG_IsOK(res1)) {
19424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19425 }
19426 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19427 {
19428 PyThreadState* __tstate = wxPyBeginAllowThreads();
19429 result = (arg1)->GetPosition();
19430 wxPyEndAllowThreads(__tstate);
19431 if (PyErr_Occurred()) SWIG_fail;
19432 }
19433 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19434 return resultobj;
19435 fail:
19436 return NULL;
19437 }
19438
19439
19440 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19441 PyObject *resultobj = 0;
19442 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19443 bool result;
19444 void *argp1 = 0 ;
19445 int res1 = 0 ;
19446 PyObject *swig_obj[1] ;
19447
19448 if (!args) SWIG_fail;
19449 swig_obj[0] = args;
19450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19451 if (!SWIG_IsOK(res1)) {
19452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19453 }
19454 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 result = (bool)(arg1)->Selecting();
19458 wxPyEndAllowThreads(__tstate);
19459 if (PyErr_Occurred()) SWIG_fail;
19460 }
19461 {
19462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19463 }
19464 return resultobj;
19465 fail:
19466 return NULL;
19467 }
19468
19469
19470 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19471 PyObject *resultobj = 0;
19472 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19473 bool result;
19474 void *argp1 = 0 ;
19475 int res1 = 0 ;
19476 PyObject *swig_obj[1] ;
19477
19478 if (!args) SWIG_fail;
19479 swig_obj[0] = args;
19480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19481 if (!SWIG_IsOK(res1)) {
19482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19483 }
19484 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = (bool)(arg1)->ControlDown();
19488 wxPyEndAllowThreads(__tstate);
19489 if (PyErr_Occurred()) SWIG_fail;
19490 }
19491 {
19492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19493 }
19494 return resultobj;
19495 fail:
19496 return NULL;
19497 }
19498
19499
19500 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19501 PyObject *resultobj = 0;
19502 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19503 bool result;
19504 void *argp1 = 0 ;
19505 int res1 = 0 ;
19506 PyObject *swig_obj[1] ;
19507
19508 if (!args) SWIG_fail;
19509 swig_obj[0] = args;
19510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19511 if (!SWIG_IsOK(res1)) {
19512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19513 }
19514 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 result = (bool)(arg1)->MetaDown();
19518 wxPyEndAllowThreads(__tstate);
19519 if (PyErr_Occurred()) SWIG_fail;
19520 }
19521 {
19522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19523 }
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19531 PyObject *resultobj = 0;
19532 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19533 bool result;
19534 void *argp1 = 0 ;
19535 int res1 = 0 ;
19536 PyObject *swig_obj[1] ;
19537
19538 if (!args) SWIG_fail;
19539 swig_obj[0] = args;
19540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19541 if (!SWIG_IsOK(res1)) {
19542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19543 }
19544 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 result = (bool)(arg1)->ShiftDown();
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 {
19552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19553 }
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19563 bool result;
19564 void *argp1 = 0 ;
19565 int res1 = 0 ;
19566 PyObject *swig_obj[1] ;
19567
19568 if (!args) SWIG_fail;
19569 swig_obj[0] = args;
19570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19571 if (!SWIG_IsOK(res1)) {
19572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19573 }
19574 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19575 {
19576 PyThreadState* __tstate = wxPyBeginAllowThreads();
19577 result = (bool)(arg1)->AltDown();
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 {
19582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19583 }
19584 return resultobj;
19585 fail:
19586 return NULL;
19587 }
19588
19589
19590 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19591 PyObject *resultobj = 0;
19592 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19593 bool result;
19594 void *argp1 = 0 ;
19595 int res1 = 0 ;
19596 PyObject *swig_obj[1] ;
19597
19598 if (!args) SWIG_fail;
19599 swig_obj[0] = args;
19600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19601 if (!SWIG_IsOK(res1)) {
19602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19603 }
19604 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19605 {
19606 PyThreadState* __tstate = wxPyBeginAllowThreads();
19607 result = (bool)(arg1)->CmdDown();
19608 wxPyEndAllowThreads(__tstate);
19609 if (PyErr_Occurred()) SWIG_fail;
19610 }
19611 {
19612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19613 }
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19621 PyObject *obj;
19622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19623 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19624 return SWIG_Py_Void();
19625 }
19626
19627 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19628 return SWIG_Python_InitShadowInstance(args);
19629 }
19630
19631 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19632 PyObject *resultobj = 0;
19633 int arg1 ;
19634 wxEventType arg2 ;
19635 wxGrid *arg3 = (wxGrid *) 0 ;
19636 int arg4 = (int) -1 ;
19637 int arg5 = (int) -1 ;
19638 int arg6 = (int) -1 ;
19639 bool arg7 = (bool) false ;
19640 bool arg8 = (bool) false ;
19641 bool arg9 = (bool) false ;
19642 bool arg10 = (bool) false ;
19643 wxGridSizeEvent *result = 0 ;
19644 int val1 ;
19645 int ecode1 = 0 ;
19646 int val2 ;
19647 int ecode2 = 0 ;
19648 void *argp3 = 0 ;
19649 int res3 = 0 ;
19650 int val4 ;
19651 int ecode4 = 0 ;
19652 int val5 ;
19653 int ecode5 = 0 ;
19654 int val6 ;
19655 int ecode6 = 0 ;
19656 bool val7 ;
19657 int ecode7 = 0 ;
19658 bool val8 ;
19659 int ecode8 = 0 ;
19660 bool val9 ;
19661 int ecode9 = 0 ;
19662 bool val10 ;
19663 int ecode10 = 0 ;
19664 PyObject * obj0 = 0 ;
19665 PyObject * obj1 = 0 ;
19666 PyObject * obj2 = 0 ;
19667 PyObject * obj3 = 0 ;
19668 PyObject * obj4 = 0 ;
19669 PyObject * obj5 = 0 ;
19670 PyObject * obj6 = 0 ;
19671 PyObject * obj7 = 0 ;
19672 PyObject * obj8 = 0 ;
19673 PyObject * obj9 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19679 ecode1 = SWIG_AsVal_int(obj0, &val1);
19680 if (!SWIG_IsOK(ecode1)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19682 }
19683 arg1 = static_cast< int >(val1);
19684 ecode2 = SWIG_AsVal_int(obj1, &val2);
19685 if (!SWIG_IsOK(ecode2)) {
19686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19687 }
19688 arg2 = static_cast< wxEventType >(val2);
19689 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19690 if (!SWIG_IsOK(res3)) {
19691 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19692 }
19693 arg3 = reinterpret_cast< wxGrid * >(argp3);
19694 if (obj3) {
19695 ecode4 = SWIG_AsVal_int(obj3, &val4);
19696 if (!SWIG_IsOK(ecode4)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19698 }
19699 arg4 = static_cast< int >(val4);
19700 }
19701 if (obj4) {
19702 ecode5 = SWIG_AsVal_int(obj4, &val5);
19703 if (!SWIG_IsOK(ecode5)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19705 }
19706 arg5 = static_cast< int >(val5);
19707 }
19708 if (obj5) {
19709 ecode6 = SWIG_AsVal_int(obj5, &val6);
19710 if (!SWIG_IsOK(ecode6)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19712 }
19713 arg6 = static_cast< int >(val6);
19714 }
19715 if (obj6) {
19716 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19717 if (!SWIG_IsOK(ecode7)) {
19718 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19719 }
19720 arg7 = static_cast< bool >(val7);
19721 }
19722 if (obj7) {
19723 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19724 if (!SWIG_IsOK(ecode8)) {
19725 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19726 }
19727 arg8 = static_cast< bool >(val8);
19728 }
19729 if (obj8) {
19730 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19731 if (!SWIG_IsOK(ecode9)) {
19732 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19733 }
19734 arg9 = static_cast< bool >(val9);
19735 }
19736 if (obj9) {
19737 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19738 if (!SWIG_IsOK(ecode10)) {
19739 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19740 }
19741 arg10 = static_cast< bool >(val10);
19742 }
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19769 }
19770 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)(arg1)->GetRowOrCol();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *resultobj = 0;
19786 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19787 wxPoint result;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 PyObject *swig_obj[1] ;
19791
19792 if (!args) SWIG_fail;
19793 swig_obj[0] = args;
19794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19795 if (!SWIG_IsOK(res1)) {
19796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19797 }
19798 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (arg1)->GetPosition();
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813 PyObject *resultobj = 0;
19814 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19815 bool result;
19816 void *argp1 = 0 ;
19817 int res1 = 0 ;
19818 PyObject *swig_obj[1] ;
19819
19820 if (!args) SWIG_fail;
19821 swig_obj[0] = args;
19822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (bool)(arg1)->ControlDown();
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19843 PyObject *resultobj = 0;
19844 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19845 bool result;
19846 void *argp1 = 0 ;
19847 int res1 = 0 ;
19848 PyObject *swig_obj[1] ;
19849
19850 if (!args) SWIG_fail;
19851 swig_obj[0] = args;
19852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19853 if (!SWIG_IsOK(res1)) {
19854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19855 }
19856 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 result = (bool)(arg1)->MetaDown();
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 {
19864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19865 }
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19873 PyObject *resultobj = 0;
19874 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19875 bool result;
19876 void *argp1 = 0 ;
19877 int res1 = 0 ;
19878 PyObject *swig_obj[1] ;
19879
19880 if (!args) SWIG_fail;
19881 swig_obj[0] = args;
19882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19885 }
19886 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19887 {
19888 PyThreadState* __tstate = wxPyBeginAllowThreads();
19889 result = (bool)(arg1)->ShiftDown();
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 {
19894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19895 }
19896 return resultobj;
19897 fail:
19898 return NULL;
19899 }
19900
19901
19902 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19903 PyObject *resultobj = 0;
19904 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19905 bool result;
19906 void *argp1 = 0 ;
19907 int res1 = 0 ;
19908 PyObject *swig_obj[1] ;
19909
19910 if (!args) SWIG_fail;
19911 swig_obj[0] = args;
19912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19913 if (!SWIG_IsOK(res1)) {
19914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19915 }
19916 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19917 {
19918 PyThreadState* __tstate = wxPyBeginAllowThreads();
19919 result = (bool)(arg1)->AltDown();
19920 wxPyEndAllowThreads(__tstate);
19921 if (PyErr_Occurred()) SWIG_fail;
19922 }
19923 {
19924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19925 }
19926 return resultobj;
19927 fail:
19928 return NULL;
19929 }
19930
19931
19932 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19933 PyObject *resultobj = 0;
19934 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19935 bool result;
19936 void *argp1 = 0 ;
19937 int res1 = 0 ;
19938 PyObject *swig_obj[1] ;
19939
19940 if (!args) SWIG_fail;
19941 swig_obj[0] = args;
19942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19943 if (!SWIG_IsOK(res1)) {
19944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19945 }
19946 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 result = (bool)(arg1)->CmdDown();
19950 wxPyEndAllowThreads(__tstate);
19951 if (PyErr_Occurred()) SWIG_fail;
19952 }
19953 {
19954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19955 }
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19963 PyObject *obj;
19964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19965 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19966 return SWIG_Py_Void();
19967 }
19968
19969 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19970 return SWIG_Python_InitShadowInstance(args);
19971 }
19972
19973 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj = 0;
19975 int arg1 ;
19976 wxEventType arg2 ;
19977 wxGrid *arg3 = (wxGrid *) 0 ;
19978 wxGridCellCoords *arg4 = 0 ;
19979 wxGridCellCoords *arg5 = 0 ;
19980 bool arg6 = (bool) true ;
19981 bool arg7 = (bool) false ;
19982 bool arg8 = (bool) false ;
19983 bool arg9 = (bool) false ;
19984 bool arg10 = (bool) false ;
19985 wxGridRangeSelectEvent *result = 0 ;
19986 int val1 ;
19987 int ecode1 = 0 ;
19988 int val2 ;
19989 int ecode2 = 0 ;
19990 void *argp3 = 0 ;
19991 int res3 = 0 ;
19992 wxGridCellCoords temp4 ;
19993 wxGridCellCoords temp5 ;
19994 bool val6 ;
19995 int ecode6 = 0 ;
19996 bool val7 ;
19997 int ecode7 = 0 ;
19998 bool val8 ;
19999 int ecode8 = 0 ;
20000 bool val9 ;
20001 int ecode9 = 0 ;
20002 bool val10 ;
20003 int ecode10 = 0 ;
20004 PyObject * obj0 = 0 ;
20005 PyObject * obj1 = 0 ;
20006 PyObject * obj2 = 0 ;
20007 PyObject * obj3 = 0 ;
20008 PyObject * obj4 = 0 ;
20009 PyObject * obj5 = 0 ;
20010 PyObject * obj6 = 0 ;
20011 PyObject * obj7 = 0 ;
20012 PyObject * obj8 = 0 ;
20013 PyObject * obj9 = 0 ;
20014 char * kwnames[] = {
20015 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
20016 };
20017
20018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
20019 ecode1 = SWIG_AsVal_int(obj0, &val1);
20020 if (!SWIG_IsOK(ecode1)) {
20021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
20022 }
20023 arg1 = static_cast< int >(val1);
20024 ecode2 = SWIG_AsVal_int(obj1, &val2);
20025 if (!SWIG_IsOK(ecode2)) {
20026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20027 }
20028 arg2 = static_cast< wxEventType >(val2);
20029 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
20030 if (!SWIG_IsOK(res3)) {
20031 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
20032 }
20033 arg3 = reinterpret_cast< wxGrid * >(argp3);
20034 {
20035 arg4 = &temp4;
20036 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
20037 }
20038 {
20039 arg5 = &temp5;
20040 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
20041 }
20042 if (obj5) {
20043 ecode6 = SWIG_AsVal_bool(obj5, &val6);
20044 if (!SWIG_IsOK(ecode6)) {
20045 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
20046 }
20047 arg6 = static_cast< bool >(val6);
20048 }
20049 if (obj6) {
20050 ecode7 = SWIG_AsVal_bool(obj6, &val7);
20051 if (!SWIG_IsOK(ecode7)) {
20052 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
20053 }
20054 arg7 = static_cast< bool >(val7);
20055 }
20056 if (obj7) {
20057 ecode8 = SWIG_AsVal_bool(obj7, &val8);
20058 if (!SWIG_IsOK(ecode8)) {
20059 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
20060 }
20061 arg8 = static_cast< bool >(val8);
20062 }
20063 if (obj8) {
20064 ecode9 = SWIG_AsVal_bool(obj8, &val9);
20065 if (!SWIG_IsOK(ecode9)) {
20066 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
20067 }
20068 arg9 = static_cast< bool >(val9);
20069 }
20070 if (obj9) {
20071 ecode10 = SWIG_AsVal_bool(obj9, &val10);
20072 if (!SWIG_IsOK(ecode10)) {
20073 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
20074 }
20075 arg10 = static_cast< bool >(val10);
20076 }
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20091 PyObject *resultobj = 0;
20092 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20093 wxGridCellCoords result;
20094 void *argp1 = 0 ;
20095 int res1 = 0 ;
20096 PyObject *swig_obj[1] ;
20097
20098 if (!args) SWIG_fail;
20099 swig_obj[0] = args;
20100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20101 if (!SWIG_IsOK(res1)) {
20102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20103 }
20104 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (arg1)->GetTopLeftCoords();
20108 wxPyEndAllowThreads(__tstate);
20109 if (PyErr_Occurred()) SWIG_fail;
20110 }
20111 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20112 return resultobj;
20113 fail:
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20119 PyObject *resultobj = 0;
20120 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20121 wxGridCellCoords result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 PyObject *swig_obj[1] ;
20125
20126 if (!args) SWIG_fail;
20127 swig_obj[0] = args;
20128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20129 if (!SWIG_IsOK(res1)) {
20130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20131 }
20132 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (arg1)->GetBottomRightCoords();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20149 int result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20159 }
20160 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (int)(arg1)->GetTopRow();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_From_int(static_cast< int >(result));
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *resultobj = 0;
20176 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20177 int 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_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20187 }
20188 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (int)(arg1)->GetBottomRow();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_From_int(static_cast< int >(result));
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20203 PyObject *resultobj = 0;
20204 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20205 int result;
20206 void *argp1 = 0 ;
20207 int res1 = 0 ;
20208 PyObject *swig_obj[1] ;
20209
20210 if (!args) SWIG_fail;
20211 swig_obj[0] = args;
20212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20213 if (!SWIG_IsOK(res1)) {
20214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20215 }
20216 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (int)(arg1)->GetLeftCol();
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 resultobj = SWIG_From_int(static_cast< int >(result));
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20231 PyObject *resultobj = 0;
20232 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20233 int result;
20234 void *argp1 = 0 ;
20235 int res1 = 0 ;
20236 PyObject *swig_obj[1] ;
20237
20238 if (!args) SWIG_fail;
20239 swig_obj[0] = args;
20240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20243 }
20244 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (int)(arg1)->GetRightCol();
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 resultobj = SWIG_From_int(static_cast< int >(result));
20252 return resultobj;
20253 fail:
20254 return NULL;
20255 }
20256
20257
20258 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20261 bool result;
20262 void *argp1 = 0 ;
20263 int res1 = 0 ;
20264 PyObject *swig_obj[1] ;
20265
20266 if (!args) SWIG_fail;
20267 swig_obj[0] = args;
20268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20269 if (!SWIG_IsOK(res1)) {
20270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20271 }
20272 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20273 {
20274 PyThreadState* __tstate = wxPyBeginAllowThreads();
20275 result = (bool)(arg1)->Selecting();
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 {
20280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20281 }
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20289 PyObject *resultobj = 0;
20290 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20291 bool result;
20292 void *argp1 = 0 ;
20293 int res1 = 0 ;
20294 PyObject *swig_obj[1] ;
20295
20296 if (!args) SWIG_fail;
20297 swig_obj[0] = args;
20298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20299 if (!SWIG_IsOK(res1)) {
20300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20301 }
20302 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 result = (bool)(arg1)->ControlDown();
20306 wxPyEndAllowThreads(__tstate);
20307 if (PyErr_Occurred()) SWIG_fail;
20308 }
20309 {
20310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20311 }
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20319 PyObject *resultobj = 0;
20320 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20321 bool result;
20322 void *argp1 = 0 ;
20323 int res1 = 0 ;
20324 PyObject *swig_obj[1] ;
20325
20326 if (!args) SWIG_fail;
20327 swig_obj[0] = args;
20328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20329 if (!SWIG_IsOK(res1)) {
20330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20331 }
20332 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20333 {
20334 PyThreadState* __tstate = wxPyBeginAllowThreads();
20335 result = (bool)(arg1)->MetaDown();
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 {
20340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20341 }
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20349 PyObject *resultobj = 0;
20350 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20351 bool result;
20352 void *argp1 = 0 ;
20353 int res1 = 0 ;
20354 PyObject *swig_obj[1] ;
20355
20356 if (!args) SWIG_fail;
20357 swig_obj[0] = args;
20358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20359 if (!SWIG_IsOK(res1)) {
20360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20361 }
20362 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (bool)(arg1)->ShiftDown();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 {
20370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20371 }
20372 return resultobj;
20373 fail:
20374 return NULL;
20375 }
20376
20377
20378 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20379 PyObject *resultobj = 0;
20380 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20381 bool result;
20382 void *argp1 = 0 ;
20383 int res1 = 0 ;
20384 PyObject *swig_obj[1] ;
20385
20386 if (!args) SWIG_fail;
20387 swig_obj[0] = args;
20388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20389 if (!SWIG_IsOK(res1)) {
20390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20391 }
20392 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 result = (bool)(arg1)->AltDown();
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 {
20400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20401 }
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *resultobj = 0;
20410 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20411 bool result;
20412 void *argp1 = 0 ;
20413 int res1 = 0 ;
20414 PyObject *swig_obj[1] ;
20415
20416 if (!args) SWIG_fail;
20417 swig_obj[0] = args;
20418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20419 if (!SWIG_IsOK(res1)) {
20420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20421 }
20422 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20423 {
20424 PyThreadState* __tstate = wxPyBeginAllowThreads();
20425 result = (bool)(arg1)->CmdDown();
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 {
20430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20431 }
20432 return resultobj;
20433 fail:
20434 return NULL;
20435 }
20436
20437
20438 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20439 PyObject *obj;
20440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20441 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20442 return SWIG_Py_Void();
20443 }
20444
20445 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 return SWIG_Python_InitShadowInstance(args);
20447 }
20448
20449 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20450 PyObject *resultobj = 0;
20451 int arg1 ;
20452 wxEventType arg2 ;
20453 wxObject *arg3 = (wxObject *) 0 ;
20454 int arg4 ;
20455 int arg5 ;
20456 wxControl *arg6 = (wxControl *) 0 ;
20457 wxGridEditorCreatedEvent *result = 0 ;
20458 int val1 ;
20459 int ecode1 = 0 ;
20460 int val2 ;
20461 int ecode2 = 0 ;
20462 void *argp3 = 0 ;
20463 int res3 = 0 ;
20464 int val4 ;
20465 int ecode4 = 0 ;
20466 int val5 ;
20467 int ecode5 = 0 ;
20468 void *argp6 = 0 ;
20469 int res6 = 0 ;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 PyObject * obj2 = 0 ;
20473 PyObject * obj3 = 0 ;
20474 PyObject * obj4 = 0 ;
20475 PyObject * obj5 = 0 ;
20476 char * kwnames[] = {
20477 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20478 };
20479
20480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20481 ecode1 = SWIG_AsVal_int(obj0, &val1);
20482 if (!SWIG_IsOK(ecode1)) {
20483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20484 }
20485 arg1 = static_cast< int >(val1);
20486 ecode2 = SWIG_AsVal_int(obj1, &val2);
20487 if (!SWIG_IsOK(ecode2)) {
20488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20489 }
20490 arg2 = static_cast< wxEventType >(val2);
20491 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20492 if (!SWIG_IsOK(res3)) {
20493 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20494 }
20495 arg3 = reinterpret_cast< wxObject * >(argp3);
20496 ecode4 = SWIG_AsVal_int(obj3, &val4);
20497 if (!SWIG_IsOK(ecode4)) {
20498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20499 }
20500 arg4 = static_cast< int >(val4);
20501 ecode5 = SWIG_AsVal_int(obj4, &val5);
20502 if (!SWIG_IsOK(ecode5)) {
20503 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20504 }
20505 arg5 = static_cast< int >(val5);
20506 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20507 if (!SWIG_IsOK(res6)) {
20508 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20509 }
20510 arg6 = reinterpret_cast< wxControl * >(argp6);
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20527 int result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20537 }
20538 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (int)(arg1)->GetRow();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 resultobj = SWIG_From_int(static_cast< int >(result));
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20555 int result;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 PyObject *swig_obj[1] ;
20559
20560 if (!args) SWIG_fail;
20561 swig_obj[0] = args;
20562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20563 if (!SWIG_IsOK(res1)) {
20564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20565 }
20566 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (int)(arg1)->GetCol();
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 resultobj = SWIG_From_int(static_cast< int >(result));
20574 return resultobj;
20575 fail:
20576 return NULL;
20577 }
20578
20579
20580 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20581 PyObject *resultobj = 0;
20582 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20583 wxControl *result = 0 ;
20584 void *argp1 = 0 ;
20585 int res1 = 0 ;
20586 PyObject *swig_obj[1] ;
20587
20588 if (!args) SWIG_fail;
20589 swig_obj[0] = args;
20590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20591 if (!SWIG_IsOK(res1)) {
20592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20593 }
20594 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 result = (wxControl *)(arg1)->GetControl();
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 {
20602 resultobj = wxPyMake_wxObject(result, 0);
20603 }
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20611 PyObject *resultobj = 0;
20612 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20613 int arg2 ;
20614 void *argp1 = 0 ;
20615 int res1 = 0 ;
20616 int val2 ;
20617 int ecode2 = 0 ;
20618 PyObject * obj0 = 0 ;
20619 PyObject * obj1 = 0 ;
20620 char * kwnames[] = {
20621 (char *) "self",(char *) "row", NULL
20622 };
20623
20624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20626 if (!SWIG_IsOK(res1)) {
20627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20628 }
20629 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20630 ecode2 = SWIG_AsVal_int(obj1, &val2);
20631 if (!SWIG_IsOK(ecode2)) {
20632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20633 }
20634 arg2 = static_cast< int >(val2);
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 (arg1)->SetRow(arg2);
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 resultobj = SWIG_Py_Void();
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj = 0;
20650 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20651 int arg2 ;
20652 void *argp1 = 0 ;
20653 int res1 = 0 ;
20654 int val2 ;
20655 int ecode2 = 0 ;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 char * kwnames[] = {
20659 (char *) "self",(char *) "col", NULL
20660 };
20661
20662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20664 if (!SWIG_IsOK(res1)) {
20665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20666 }
20667 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20668 ecode2 = SWIG_AsVal_int(obj1, &val2);
20669 if (!SWIG_IsOK(ecode2)) {
20670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20671 }
20672 arg2 = static_cast< int >(val2);
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 (arg1)->SetCol(arg2);
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 resultobj = SWIG_Py_Void();
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20687 PyObject *resultobj = 0;
20688 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20689 wxControl *arg2 = (wxControl *) 0 ;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 void *argp2 = 0 ;
20693 int res2 = 0 ;
20694 PyObject * obj0 = 0 ;
20695 PyObject * obj1 = 0 ;
20696 char * kwnames[] = {
20697 (char *) "self",(char *) "ctrl", NULL
20698 };
20699
20700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20704 }
20705 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20707 if (!SWIG_IsOK(res2)) {
20708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20709 }
20710 arg2 = reinterpret_cast< wxControl * >(argp2);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 (arg1)->SetControl(arg2);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 resultobj = SWIG_Py_Void();
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20725 PyObject *obj;
20726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20727 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20728 return SWIG_Py_Void();
20729 }
20730
20731 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20732 return SWIG_Python_InitShadowInstance(args);
20733 }
20734
20735 static PyMethodDef SwigMethods[] = {
20736 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20738 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20740 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20741 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20742 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20745 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20746 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20747 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20750 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20751 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20752 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20753 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20754 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20755 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20756 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20757 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20759 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20761 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20763 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20764 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20765 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20766 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20767 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20769 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20770 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20772 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20773 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20774 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20775 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20776 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20777 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20778 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20780 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20785 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20786 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20792 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20794 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20795 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20796 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20799 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20800 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20801 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20802 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20803 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20804 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20806 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20807 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20809 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20810 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20811 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20814 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20815 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20817 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20818 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20820 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20821 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20822 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20823 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20824 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20827 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20828 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20830 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20831 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20842 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20843 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20844 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20845 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20846 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20847 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20848 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20849 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20850 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20851 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20852 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20853 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20854 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20855 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20858 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20859 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20861 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20862 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20863 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20871 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20872 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20873 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20879 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20880 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20881 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20884 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20886 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20887 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20888 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20901 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20912 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20917 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20918 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20920 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20921 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20922 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20924 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20925 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20927 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20929 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20931 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20933 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20935 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20936 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20937 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20939 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20940 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20942 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20947 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20948 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20949 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20951 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20955 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20956 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20957 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20959 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20961 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20971 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20972 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20973 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20974 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20975 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20978 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20979 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20980 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20981 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20982 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20983 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20984 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20985 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20992 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20993 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
21001 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
21002 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
21007 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
21008 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
21009 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
21010 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
21011 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
21012 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
21013 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
21014 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
21015 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
21016 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
21019 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
21020 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
21023 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
21024 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
21025 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
21041 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
21042 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
21044 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
21045 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
21047 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
21048 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
21050 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
21051 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
21053 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
21054 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
21064 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
21065 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
21067 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
21069 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
21071 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
21073 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
21075 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
21077 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
21091 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
21098 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
21099 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21113 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21117 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21119 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21121 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21126 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21127 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21128 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21129 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21130 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21131 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21132 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21133 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21134 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21135 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21136 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21139 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21140 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21141 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21142 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21144 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21145 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21146 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21148 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21149 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21150 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21151 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21152 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21153 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21154 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21155 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21156 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21157 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21158 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21159 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21160 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21161 { (char *)"new_GridUpdateLocker", (PyCFunction) _wrap_new_GridUpdateLocker, METH_VARARGS | METH_KEYWORDS, NULL},
21162 { (char *)"delete_GridUpdateLocker", (PyCFunction)_wrap_delete_GridUpdateLocker, METH_O, NULL},
21163 { (char *)"GridUpdateLocker_Create", (PyCFunction) _wrap_GridUpdateLocker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"GridUpdateLocker_swigregister", GridUpdateLocker_swigregister, METH_VARARGS, NULL},
21165 { (char *)"GridUpdateLocker_swiginit", GridUpdateLocker_swiginit, METH_VARARGS, NULL},
21166 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21167 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21168 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21169 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21170 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21171 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21172 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21173 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21174 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21175 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21176 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21177 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21178 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21179 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21180 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21181 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21182 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21183 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21184 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21185 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21186 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21187 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21188 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21189 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21190 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21191 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21192 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21193 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21194 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21195 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21196 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21197 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21198 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21199 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21200 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21201 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21202 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21203 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21204 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21205 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21206 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21207 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21208 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21209 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21211 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21212 { NULL, NULL, 0, NULL }
21213 };
21214
21215
21216 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21217
21218 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21219 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21220 }
21221 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21222 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21223 }
21224 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21225 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21226 }
21227 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21228 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21229 }
21230 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21231 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21232 }
21233 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21234 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21235 }
21236 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21237 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21238 }
21239 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21240 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21241 }
21242 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21243 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21244 }
21245 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21246 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21247 }
21248 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21249 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21250 }
21251 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21252 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21253 }
21254 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21255 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21256 }
21257 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21258 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21259 }
21260 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21261 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21262 }
21263 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21264 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21265 }
21266 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21267 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21268 }
21269 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21270 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21271 }
21272 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21273 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21274 }
21275 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21276 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21277 }
21278 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21279 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21280 }
21281 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21282 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21283 }
21284 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21285 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21286 }
21287 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21288 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21289 }
21290 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21291 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21292 }
21293 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21294 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21295 }
21296 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21297 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21298 }
21299 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21300 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21301 }
21302 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21303 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21304 }
21305 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21306 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21307 }
21308 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21309 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21310 }
21311 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21312 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21313 }
21314 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21315 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21316 }
21317 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21318 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21319 }
21320 static void *_p_wxGridTo_p_wxPanel(void *x) {
21321 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21322 }
21323 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21324 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21325 }
21326 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21327 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21328 }
21329 static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
21330 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21331 }
21332 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21333 return (void *)((wxPanel *) ((wxPyPanel *) x));
21334 }
21335 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21336 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21337 }
21338 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21339 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21340 }
21341 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21342 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21343 }
21344 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21345 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21346 }
21347 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21348 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21349 }
21350 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21351 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21352 }
21353 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21354 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21355 }
21356 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21357 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21358 }
21359 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21360 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21361 }
21362 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21363 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21364 }
21365 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21366 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21367 }
21368 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21369 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21370 }
21371 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21372 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21373 }
21374 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21375 return (void *)((wxWindow *) ((wxMenuBar *) x));
21376 }
21377 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21378 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21379 }
21380 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21381 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21382 }
21383 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21384 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21385 }
21386 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21387 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21388 }
21389 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21390 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21391 }
21392 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21393 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21394 }
21395 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21396 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21397 }
21398 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21399 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21400 }
21401 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21402 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21403 }
21404 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21405 return (void *)((wxWindow *) ((wxPanel *) x));
21406 }
21407 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21408 return (void *)((wxWindow *) ((wxStatusBar *) x));
21409 }
21410 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21411 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21412 }
21413 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21414 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21415 }
21416 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21417 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21418 }
21419 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21420 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21421 }
21422 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21423 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21424 }
21425 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21426 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21427 }
21428 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21429 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21430 }
21431 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21432 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21433 }
21434 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21435 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21436 }
21437 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21438 return (void *)((wxWindow *) ((wxSashWindow *) x));
21439 }
21440 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21441 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21442 }
21443 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21444 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21445 }
21446 static void *_p_wxControlTo_p_wxWindow(void *x) {
21447 return (void *)((wxWindow *) ((wxControl *) x));
21448 }
21449 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21450 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21451 }
21452 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21453 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21454 }
21455 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21456 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21457 }
21458 static void *_p_wxGridTo_p_wxWindow(void *x) {
21459 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21460 }
21461 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21462 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21463 }
21464 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21465 return (void *)((wxWindow *) ((wxPyWindow *) x));
21466 }
21467 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21468 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21469 }
21470 static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
21471 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21472 }
21473 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21474 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21475 }
21476 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21477 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21478 }
21479 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21480 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21481 }
21482 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21483 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21484 }
21485 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21486 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21487 }
21488 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21489 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21490 }
21491 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21492 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21493 }
21494 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21495 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21496 }
21497 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21498 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21499 }
21500 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21501 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21502 }
21503 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21504 return (void *)((wxControl *) ((wxControlWithItems *) x));
21505 }
21506 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21507 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21508 }
21509 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21510 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21511 }
21512 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21513 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21514 }
21515 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21516 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21517 }
21518 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21519 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21520 }
21521 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21522 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21523 }
21524 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21525 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21526 }
21527 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21528 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21529 }
21530 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21531 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21532 }
21533 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21534 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21535 }
21536 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21537 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21538 }
21539 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21540 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21541 }
21542 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21543 return (void *)((wxEvent *) ((wxPyEvent *) x));
21544 }
21545 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21546 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21547 }
21548 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21549 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21550 }
21551 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21552 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21553 }
21554 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21555 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21556 }
21557 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21558 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21559 }
21560 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21561 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21562 }
21563 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21564 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21565 }
21566 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21567 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21568 }
21569 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21570 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21571 }
21572 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21573 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21574 }
21575 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21576 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21577 }
21578 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21579 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21580 }
21581 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21582 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21583 }
21584 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21585 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21586 }
21587 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21588 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21589 }
21590 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21591 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21592 }
21593 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21594 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21595 }
21596 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21597 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21598 }
21599 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21600 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21601 }
21602 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21603 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21604 }
21605 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21606 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21607 }
21608 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21609 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21610 }
21611 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21612 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21613 }
21614 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21615 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21616 }
21617 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21618 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21619 }
21620 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21621 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21622 }
21623 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21624 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21625 }
21626 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21627 return (void *)((wxEvent *) ((wxShowEvent *) x));
21628 }
21629 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21630 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21631 }
21632 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21633 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21634 }
21635 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21636 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21637 }
21638 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21639 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21640 }
21641 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21642 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21643 }
21644 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21645 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21646 }
21647 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21648 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21649 }
21650 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21651 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21652 }
21653 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21654 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21655 }
21656 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
21657 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
21658 }
21659 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21660 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21661 }
21662 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21663 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21664 }
21665 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21666 return (void *)((wxObject *) ((wxSizerItem *) x));
21667 }
21668 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21669 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21670 }
21671 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21672 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21673 }
21674 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21675 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21676 }
21677 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21678 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21679 }
21680 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21681 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21682 }
21683 static void *_p_wxSizerTo_p_wxObject(void *x) {
21684 return (void *)((wxObject *) ((wxSizer *) x));
21685 }
21686 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21687 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21688 }
21689 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21690 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21691 }
21692 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21693 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21694 }
21695 static void *_p_wxEventTo_p_wxObject(void *x) {
21696 return (void *)((wxObject *) ((wxEvent *) x));
21697 }
21698 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21699 return (void *)((wxObject *) ((wxFontData *) x));
21700 }
21701 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21702 return (void *)((wxObject *) ((wxPrintData *) x));
21703 }
21704 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21705 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21706 }
21707 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21708 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21709 }
21710 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21711 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21712 }
21713 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21714 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21715 }
21716 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21717 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21718 }
21719 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21720 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21721 }
21722 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21723 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21724 }
21725 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21726 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21727 }
21728 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21729 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21730 }
21731 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21732 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21733 }
21734 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21735 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21736 }
21737 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21738 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21739 }
21740 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21741 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21742 }
21743 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21744 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21745 }
21746 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21747 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21748 }
21749 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21750 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21751 }
21752 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21753 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21754 }
21755 static void *_p_wxControlTo_p_wxObject(void *x) {
21756 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21757 }
21758 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21759 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21760 }
21761 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21762 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21763 }
21764 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21765 return (void *)((wxObject *) ((wxFSFile *) x));
21766 }
21767 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21768 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21769 }
21770 static void *_p_wxGridTo_p_wxObject(void *x) {
21771 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21772 }
21773 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21774 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21775 }
21776 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21777 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21778 }
21779 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21780 return (void *)((wxObject *) ((wxColourData *) x));
21781 }
21782 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21783 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21784 }
21785 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21786 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21787 }
21788 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21789 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21790 }
21791 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21792 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21793 }
21794 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21795 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21796 }
21797 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21798 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21799 }
21800 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21801 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21802 }
21803 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21804 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21805 }
21806 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21807 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21808 }
21809 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21810 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21811 }
21812 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21813 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21814 }
21815 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21816 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21817 }
21818 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21819 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21820 }
21821 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21822 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21823 }
21824 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21825 return (void *)((wxObject *) ((wxPrinter *) x));
21826 }
21827 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21828 return (void *)((wxObject *) ((wxMenuItem *) x));
21829 }
21830 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21831 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21832 }
21833 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21834 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21835 }
21836 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21837 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21838 }
21839 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21840 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21841 }
21842 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21843 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21844 }
21845 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21846 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21847 }
21848 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21849 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21850 }
21851 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21852 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21853 }
21854 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21855 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21856 }
21857 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21858 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21859 }
21860 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21861 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21862 }
21863 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21864 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21865 }
21866 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21867 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21868 }
21869 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21870 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21871 }
21872 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21873 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21874 }
21875 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21876 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21877 }
21878 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21879 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21880 }
21881 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21882 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21883 }
21884 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21885 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21886 }
21887 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21888 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21889 }
21890 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21891 return (void *)((wxObject *) ((wxImageHandler *) x));
21892 }
21893 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21894 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21895 }
21896 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21897 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21898 }
21899 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21900 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21901 }
21902 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21903 return (void *)((wxObject *) ((wxEvtHandler *) x));
21904 }
21905 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21906 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21907 }
21908 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21909 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21910 }
21911 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21912 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21913 }
21914 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21915 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21916 }
21917 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21918 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21919 }
21920 static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
21921 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21922 }
21923 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21924 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21925 }
21926 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21927 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21928 }
21929 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21930 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21931 }
21932 static void *_p_wxImageTo_p_wxObject(void *x) {
21933 return (void *)((wxObject *) ((wxImage *) x));
21934 }
21935 static void *_p_wxFrameTo_p_wxObject(void *x) {
21936 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21937 }
21938 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21939 return (void *)((wxObject *) ((wxPyPrintout *) x));
21940 }
21941 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21942 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21943 }
21944 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21945 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21946 }
21947 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21948 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21949 }
21950 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21951 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21952 }
21953 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21954 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21955 }
21956 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21957 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21958 }
21959 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21960 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21961 }
21962 static void *_p_wxWindowTo_p_wxObject(void *x) {
21963 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21964 }
21965 static void *_p_wxMenuTo_p_wxObject(void *x) {
21966 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21967 }
21968 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21969 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21970 }
21971 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21972 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21973 }
21974 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21975 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21976 }
21977 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21978 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21979 }
21980 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21981 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21982 }
21983 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21984 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21985 }
21986 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21987 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21988 }
21989 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21990 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21991 }
21992 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21993 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21994 }
21995 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21996 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21997 }
21998 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21999 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22000 }
22001 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
22002 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
22003 }
22004 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
22005 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22006 }
22007 static void *_p_wxSashEventTo_p_wxObject(void *x) {
22008 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
22009 }
22010 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
22011 return (void *)((wxObject *) ((wxPrintPreview *) x));
22012 }
22013 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
22014 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
22015 }
22016 static void *_p_wxPanelTo_p_wxObject(void *x) {
22017 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
22018 }
22019 static void *_p_wxDialogTo_p_wxObject(void *x) {
22020 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22021 }
22022 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
22023 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22024 }
22025 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
22026 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22027 }
22028 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
22029 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22030 }
22031 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
22032 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
22033 }
22034 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
22035 return (void *)((wxObject *) ((wxPrintDialog *) x));
22036 }
22037 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22038 return (void *)((wxObject *) ((wxFileSystem *) x));
22039 }
22040 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22041 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22042 }
22043 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22044 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22045 }
22046 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22047 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22048 }
22049 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22050 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22051 }
22052 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22053 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22054 }
22055 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22056 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22057 }
22058 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
22059 return (void *)((wxObject *) ((wxGridTableBase *) x));
22060 }
22061 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
22062 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
22063 }
22064 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22065 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22066 }
22067 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22068 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22069 }
22070 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
22071 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22072 }
22073 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
22074 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22075 }
22076 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22077 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22078 }
22079 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22080 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22081 }
22082 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22084 }
22085 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22086 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22087 }
22088 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
22089 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
22090 }
22091 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
22092 return (void *)((wxObject *) ((wxPrintDialogData *) x));
22093 }
22094 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22095 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22096 }
22097 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22098 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22099 }
22100 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
22101 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
22102 }
22103 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
22104 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
22105 }
22106 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
22107 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
22108 }
22109 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
22110 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
22111 }
22112 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
22113 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
22114 }
22115 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
22116 return (void *)((wxEvtHandler *) ((wxValidator *) x));
22117 }
22118 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
22119 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
22120 }
22121 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
22122 return (void *)((wxEvtHandler *) ((wxMenu *) x));
22123 }
22124 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
22125 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
22126 }
22127 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22128 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22129 }
22130 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22131 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22132 }
22133 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
22134 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
22135 }
22136 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
22137 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
22138 }
22139 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22140 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22141 }
22142 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22143 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22144 }
22145 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22146 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22147 }
22148 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22149 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22150 }
22151 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22152 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22153 }
22154 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22155 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22156 }
22157 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22158 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22159 }
22160 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22161 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22162 }
22163 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22164 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22165 }
22166 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22167 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22168 }
22169 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22170 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22171 }
22172 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22173 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22174 }
22175 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22176 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22177 }
22178 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22179 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22180 }
22181 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22182 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22183 }
22184 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22185 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22186 }
22187 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22188 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22189 }
22190 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22191 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22192 }
22193 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22194 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22195 }
22196 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22197 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22198 }
22199 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22200 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22201 }
22202 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22203 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22204 }
22205 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22206 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22207 }
22208 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22209 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22210 }
22211 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22212 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22213 }
22214 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22215 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22216 }
22217 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22218 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22219 }
22220 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22221 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22222 }
22223 static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
22224 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
22225 }
22226 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22227 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22228 }
22229 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22230 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22231 }
22232 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22233 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22234 }
22235 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22236 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22237 }
22238 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22239 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22240 }
22241 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22242 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22243 }
22244 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22245 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22246 }
22247 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22248 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22249 }
22250 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22251 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22252 }
22253 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22254 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22255 }
22256 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22257 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22258 }
22259 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22260 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22261 }
22262 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22263 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22264 }
22265 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22266 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22267 }
22268 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22269 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22270 }
22271 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22272 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22273 }
22274 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22275 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22276 }
22277 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22278 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22279 }
22280 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22281 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22282 }
22283 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22284 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22285 }
22286 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22287 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22288 }
22289 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22290 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22291 }
22292 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22293 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22294 }
22295 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22296 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22297 }
22298 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22299 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22300 }
22301 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22302 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22303 }
22304 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22305 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22306 }
22307 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22308 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22309 }
22310 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22311 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22312 }
22313 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22314 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22315 }
22316 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22317 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22318 }
22319 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22320 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22321 }
22322 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22323 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22324 }
22325 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22326 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22327 }
22328 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22329 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22330 }
22331 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22332 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22333 }
22334 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22335 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22336 }
22337 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22338 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22339 }
22340 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22341 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22342 }
22343 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22344 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22345 }
22346 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22347 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22348 }
22349 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22350 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22351 }
22352 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22353 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22354 }
22355 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22356 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};
22357 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22358 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22359 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22360 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22361 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22362 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22363 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22364 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22365 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22366 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22367 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22368 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22369 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22370 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22371 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22372 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22373 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22374 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22375 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22376 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22378 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22380 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22381 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22382 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22398 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22399 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22400 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22401 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22402 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22403 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22404 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22405 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22406 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22407 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22408 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22409 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22410 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22411 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22412 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22413 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22414 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22415 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
22416 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22417 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22418 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22419 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22420 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22421 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22422 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22423 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22424 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22425 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22426 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22427 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22428 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22429 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22430 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22431 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22432 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22433 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22434 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22435 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22436 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22437 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22438 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22439 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22440 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22441 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22442 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22443 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22444 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22445 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22446 static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
22447 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22448 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22449 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22450 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22451 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22452 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22453 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22454 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22455 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22456 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22457 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22458 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22459 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22460 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22461 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22462 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22463 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22464 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22465 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22466 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22467 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22468 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22469 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22470 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22471 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22472 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22473 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22474 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22475 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22476 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22477 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22478 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22479 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22480 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22481 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22482 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22483 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22484 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22485 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22486 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22487 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22488 static swig_type_info _swigt__p_wxGridUpdateLocker = {"_p_wxGridUpdateLocker", "wxGridUpdateLocker *", 0, 0, (void*)0, 0};
22489 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22490 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22491 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22492 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22493 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22494 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22495 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22496 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22497 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22498 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22499 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22500 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22501 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22502 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22503 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22504 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22505 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22506 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22507 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22508 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22509 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22510 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22511 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22512 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22513 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22514 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22515 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22516 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22517 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22518 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22519 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22520 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22521 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22522 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22523 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22524 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22525 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22526 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22527 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22528 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22529 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22530 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22531 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22532 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22533 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22534 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22535 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22536 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22537 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22538 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22539 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22540 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22541 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22542 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22543 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22544 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22545 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22546 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22547 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22548 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22549 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22550
22551 static swig_type_info *swig_type_initial[] = {
22552 &_swigt__p_char,
22553 &_swigt__p_form_ops_t,
22554 &_swigt__p_int,
22555 &_swigt__p_long,
22556 &_swigt__p_unsigned_char,
22557 &_swigt__p_unsigned_int,
22558 &_swigt__p_unsigned_long,
22559 &_swigt__p_wxANIHandler,
22560 &_swigt__p_wxAcceleratorTable,
22561 &_swigt__p_wxActivateEvent,
22562 &_swigt__p_wxArrayString,
22563 &_swigt__p_wxBMPHandler,
22564 &_swigt__p_wxBoxSizer,
22565 &_swigt__p_wxCURHandler,
22566 &_swigt__p_wxCalculateLayoutEvent,
22567 &_swigt__p_wxChildFocusEvent,
22568 &_swigt__p_wxClipboardTextEvent,
22569 &_swigt__p_wxCloseEvent,
22570 &_swigt__p_wxColour,
22571 &_swigt__p_wxColourData,
22572 &_swigt__p_wxColourDialog,
22573 &_swigt__p_wxCommandEvent,
22574 &_swigt__p_wxContextMenuEvent,
22575 &_swigt__p_wxControl,
22576 &_swigt__p_wxControlWithItems,
22577 &_swigt__p_wxDC,
22578 &_swigt__p_wxDateEvent,
22579 &_swigt__p_wxDialog,
22580 &_swigt__p_wxDirDialog,
22581 &_swigt__p_wxDisplayChangedEvent,
22582 &_swigt__p_wxDropFilesEvent,
22583 &_swigt__p_wxDuplexMode,
22584 &_swigt__p_wxEraseEvent,
22585 &_swigt__p_wxEvent,
22586 &_swigt__p_wxEventBlocker,
22587 &_swigt__p_wxEvtHandler,
22588 &_swigt__p_wxFSFile,
22589 &_swigt__p_wxFileDialog,
22590 &_swigt__p_wxFileSystem,
22591 &_swigt__p_wxFindDialogEvent,
22592 &_swigt__p_wxFindReplaceData,
22593 &_swigt__p_wxFindReplaceDialog,
22594 &_swigt__p_wxFlexGridSizer,
22595 &_swigt__p_wxFocusEvent,
22596 &_swigt__p_wxFont,
22597 &_swigt__p_wxFontData,
22598 &_swigt__p_wxFontDialog,
22599 &_swigt__p_wxFrame,
22600 &_swigt__p_wxGBSizerItem,
22601 &_swigt__p_wxGIFHandler,
22602 &_swigt__p_wxGrid,
22603 &_swigt__p_wxGridBagSizer,
22604 &_swigt__p_wxGridCellAttr,
22605 &_swigt__p_wxGridCellAttrProvider,
22606 &_swigt__p_wxGridCellAutoWrapStringEditor,
22607 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22608 &_swigt__p_wxGridCellBoolEditor,
22609 &_swigt__p_wxGridCellBoolRenderer,
22610 &_swigt__p_wxGridCellChoiceEditor,
22611 &_swigt__p_wxGridCellCoords,
22612 &_swigt__p_wxGridCellDateTimeRenderer,
22613 &_swigt__p_wxGridCellEditor,
22614 &_swigt__p_wxGridCellEnumEditor,
22615 &_swigt__p_wxGridCellEnumRenderer,
22616 &_swigt__p_wxGridCellFloatEditor,
22617 &_swigt__p_wxGridCellFloatRenderer,
22618 &_swigt__p_wxGridCellNumberEditor,
22619 &_swigt__p_wxGridCellNumberRenderer,
22620 &_swigt__p_wxGridCellRenderer,
22621 &_swigt__p_wxGridCellStringRenderer,
22622 &_swigt__p_wxGridCellTextEditor,
22623 &_swigt__p_wxGridCellWorker,
22624 &_swigt__p_wxGridEditorCreatedEvent,
22625 &_swigt__p_wxGridEvent,
22626 &_swigt__p_wxGridRangeSelectEvent,
22627 &_swigt__p_wxGridSizeEvent,
22628 &_swigt__p_wxGridSizer,
22629 &_swigt__p_wxGridStringTable,
22630 &_swigt__p_wxGridTableBase,
22631 &_swigt__p_wxGridTableMessage,
22632 &_swigt__p_wxGridUpdateLocker,
22633 &_swigt__p_wxICOHandler,
22634 &_swigt__p_wxIconizeEvent,
22635 &_swigt__p_wxIdleEvent,
22636 &_swigt__p_wxImage,
22637 &_swigt__p_wxImageHandler,
22638 &_swigt__p_wxIndividualLayoutConstraint,
22639 &_swigt__p_wxInitDialogEvent,
22640 &_swigt__p_wxJPEGHandler,
22641 &_swigt__p_wxKeyEvent,
22642 &_swigt__p_wxLayoutAlgorithm,
22643 &_swigt__p_wxLayoutConstraints,
22644 &_swigt__p_wxMDIChildFrame,
22645 &_swigt__p_wxMDIClientWindow,
22646 &_swigt__p_wxMDIParentFrame,
22647 &_swigt__p_wxMaximizeEvent,
22648 &_swigt__p_wxMenu,
22649 &_swigt__p_wxMenuBar,
22650 &_swigt__p_wxMenuEvent,
22651 &_swigt__p_wxMenuItem,
22652 &_swigt__p_wxMessageDialog,
22653 &_swigt__p_wxMiniFrame,
22654 &_swigt__p_wxMouseCaptureChangedEvent,
22655 &_swigt__p_wxMouseCaptureLostEvent,
22656 &_swigt__p_wxMouseEvent,
22657 &_swigt__p_wxMoveEvent,
22658 &_swigt__p_wxMultiChoiceDialog,
22659 &_swigt__p_wxNavigationKeyEvent,
22660 &_swigt__p_wxNcPaintEvent,
22661 &_swigt__p_wxNotifyEvent,
22662 &_swigt__p_wxNumberEntryDialog,
22663 &_swigt__p_wxObject,
22664 &_swigt__p_wxPCXHandler,
22665 &_swigt__p_wxPNGHandler,
22666 &_swigt__p_wxPNMHandler,
22667 &_swigt__p_wxPageSetupDialog,
22668 &_swigt__p_wxPageSetupDialogData,
22669 &_swigt__p_wxPaintEvent,
22670 &_swigt__p_wxPaletteChangedEvent,
22671 &_swigt__p_wxPanel,
22672 &_swigt__p_wxPaperSize,
22673 &_swigt__p_wxPasswordEntryDialog,
22674 &_swigt__p_wxPen,
22675 &_swigt__p_wxPoint,
22676 &_swigt__p_wxPopupWindow,
22677 &_swigt__p_wxPreviewCanvas,
22678 &_swigt__p_wxPreviewControlBar,
22679 &_swigt__p_wxPreviewFrame,
22680 &_swigt__p_wxPrintData,
22681 &_swigt__p_wxPrintDialog,
22682 &_swigt__p_wxPrintDialogData,
22683 &_swigt__p_wxPrintPreview,
22684 &_swigt__p_wxPrinter,
22685 &_swigt__p_wxProgressDialog,
22686 &_swigt__p_wxPyApp,
22687 &_swigt__p_wxPyCommandEvent,
22688 &_swigt__p_wxPyEvent,
22689 &_swigt__p_wxPyGridCellAttrProvider,
22690 &_swigt__p_wxPyGridCellEditor,
22691 &_swigt__p_wxPyGridCellRenderer,
22692 &_swigt__p_wxPyGridTableBase,
22693 &_swigt__p_wxPyHtmlListBox,
22694 &_swigt__p_wxPyImageHandler,
22695 &_swigt__p_wxPyPanel,
22696 &_swigt__p_wxPyPopupTransientWindow,
22697 &_swigt__p_wxPyPreviewControlBar,
22698 &_swigt__p_wxPyPreviewFrame,
22699 &_swigt__p_wxPyPrintPreview,
22700 &_swigt__p_wxPyPrintout,
22701 &_swigt__p_wxPyScrolledWindow,
22702 &_swigt__p_wxPySizer,
22703 &_swigt__p_wxPyTaskBarIcon,
22704 &_swigt__p_wxPyVListBox,
22705 &_swigt__p_wxPyVScrolledWindow,
22706 &_swigt__p_wxPyValidator,
22707 &_swigt__p_wxPyWindow,
22708 &_swigt__p_wxQueryLayoutInfoEvent,
22709 &_swigt__p_wxQueryNewPaletteEvent,
22710 &_swigt__p_wxRect,
22711 &_swigt__p_wxSashEvent,
22712 &_swigt__p_wxSashLayoutWindow,
22713 &_swigt__p_wxSashWindow,
22714 &_swigt__p_wxScrollEvent,
22715 &_swigt__p_wxScrollWinEvent,
22716 &_swigt__p_wxScrolledWindow,
22717 &_swigt__p_wxSetCursorEvent,
22718 &_swigt__p_wxShowEvent,
22719 &_swigt__p_wxSimpleHtmlListBox,
22720 &_swigt__p_wxSingleChoiceDialog,
22721 &_swigt__p_wxSize,
22722 &_swigt__p_wxSizeEvent,
22723 &_swigt__p_wxSizer,
22724 &_swigt__p_wxSizerItem,
22725 &_swigt__p_wxSplashScreen,
22726 &_swigt__p_wxSplashScreenWindow,
22727 &_swigt__p_wxSplitterEvent,
22728 &_swigt__p_wxSplitterWindow,
22729 &_swigt__p_wxStaticBoxSizer,
22730 &_swigt__p_wxStatusBar,
22731 &_swigt__p_wxStdDialogButtonSizer,
22732 &_swigt__p_wxString,
22733 &_swigt__p_wxSysColourChangedEvent,
22734 &_swigt__p_wxTGAHandler,
22735 &_swigt__p_wxTIFFHandler,
22736 &_swigt__p_wxTaskBarIconEvent,
22737 &_swigt__p_wxTextEntryDialog,
22738 &_swigt__p_wxTipWindow,
22739 &_swigt__p_wxTopLevelWindow,
22740 &_swigt__p_wxUpdateUIEvent,
22741 &_swigt__p_wxValidator,
22742 &_swigt__p_wxVisualAttributes,
22743 &_swigt__p_wxWindow,
22744 &_swigt__p_wxWindowCreateEvent,
22745 &_swigt__p_wxWindowDestroyEvent,
22746 &_swigt__p_wxXPMHandler,
22747 };
22748
22749 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22752 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22753 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22754 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22755 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22756 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22757 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22758 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22763 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22764 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22766 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22767 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22770 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}};
22771 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22772 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}};
22773 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22778 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22779 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22794 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22795 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22798 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22799 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22800 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22801 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22802 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22803 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22804 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}};
22805 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22806 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22807 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22808 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
22809 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22810 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22811 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22812 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22813 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22814 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22815 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22816 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22817 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22818 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22819 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22820 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22821 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22822 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22823 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22824 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22825 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22826 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22827 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22828 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22829 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22830 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22831 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22832 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22833 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22834 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22835 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22836 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22837 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22838 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22839 static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22840 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22841 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22842 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22843 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22844 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22845 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22846 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22847 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22848 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22849 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22850 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22851 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22852 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22853 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22854 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22855 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22856 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}};
22857 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22858 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22859 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22860 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22861 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}};
22862 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22863 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22864 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}};
22865 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22866 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22867 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22868 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22869 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22870 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22871 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}};
22872 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}};
22873 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}};
22874 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}};
22875 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22876 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22877 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22878 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22879 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22880 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}};
22881 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22882 static swig_cast_info _swigc__p_wxGridUpdateLocker[] = { {&_swigt__p_wxGridUpdateLocker, 0, 0, 0},{0, 0, 0, 0}};
22883 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22884 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}};
22885 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22886 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22887 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22888 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22889 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22890 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22891 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22892 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22893 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22894 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22895 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22896 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22897 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22898 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22899 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22900 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22901 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22902 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22903 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22904 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22905 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22906 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22907 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22908 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22909 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22910 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22911 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22912 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22913 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22914 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22915 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22916 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22917 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22918 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22919 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22920 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22921 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22922 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22923 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22924 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22925 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22926 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22927 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22928 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22929 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22930 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22931 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22932 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22933 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22934 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22935 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22936 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22937 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22938 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22939 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}};
22940 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22941 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22942 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22943 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22944
22945 static swig_cast_info *swig_cast_initial[] = {
22946 _swigc__p_char,
22947 _swigc__p_form_ops_t,
22948 _swigc__p_int,
22949 _swigc__p_long,
22950 _swigc__p_unsigned_char,
22951 _swigc__p_unsigned_int,
22952 _swigc__p_unsigned_long,
22953 _swigc__p_wxANIHandler,
22954 _swigc__p_wxAcceleratorTable,
22955 _swigc__p_wxActivateEvent,
22956 _swigc__p_wxArrayString,
22957 _swigc__p_wxBMPHandler,
22958 _swigc__p_wxBoxSizer,
22959 _swigc__p_wxCURHandler,
22960 _swigc__p_wxCalculateLayoutEvent,
22961 _swigc__p_wxChildFocusEvent,
22962 _swigc__p_wxClipboardTextEvent,
22963 _swigc__p_wxCloseEvent,
22964 _swigc__p_wxColour,
22965 _swigc__p_wxColourData,
22966 _swigc__p_wxColourDialog,
22967 _swigc__p_wxCommandEvent,
22968 _swigc__p_wxContextMenuEvent,
22969 _swigc__p_wxControl,
22970 _swigc__p_wxControlWithItems,
22971 _swigc__p_wxDC,
22972 _swigc__p_wxDateEvent,
22973 _swigc__p_wxDialog,
22974 _swigc__p_wxDirDialog,
22975 _swigc__p_wxDisplayChangedEvent,
22976 _swigc__p_wxDropFilesEvent,
22977 _swigc__p_wxDuplexMode,
22978 _swigc__p_wxEraseEvent,
22979 _swigc__p_wxEvent,
22980 _swigc__p_wxEventBlocker,
22981 _swigc__p_wxEvtHandler,
22982 _swigc__p_wxFSFile,
22983 _swigc__p_wxFileDialog,
22984 _swigc__p_wxFileSystem,
22985 _swigc__p_wxFindDialogEvent,
22986 _swigc__p_wxFindReplaceData,
22987 _swigc__p_wxFindReplaceDialog,
22988 _swigc__p_wxFlexGridSizer,
22989 _swigc__p_wxFocusEvent,
22990 _swigc__p_wxFont,
22991 _swigc__p_wxFontData,
22992 _swigc__p_wxFontDialog,
22993 _swigc__p_wxFrame,
22994 _swigc__p_wxGBSizerItem,
22995 _swigc__p_wxGIFHandler,
22996 _swigc__p_wxGrid,
22997 _swigc__p_wxGridBagSizer,
22998 _swigc__p_wxGridCellAttr,
22999 _swigc__p_wxGridCellAttrProvider,
23000 _swigc__p_wxGridCellAutoWrapStringEditor,
23001 _swigc__p_wxGridCellAutoWrapStringRenderer,
23002 _swigc__p_wxGridCellBoolEditor,
23003 _swigc__p_wxGridCellBoolRenderer,
23004 _swigc__p_wxGridCellChoiceEditor,
23005 _swigc__p_wxGridCellCoords,
23006 _swigc__p_wxGridCellDateTimeRenderer,
23007 _swigc__p_wxGridCellEditor,
23008 _swigc__p_wxGridCellEnumEditor,
23009 _swigc__p_wxGridCellEnumRenderer,
23010 _swigc__p_wxGridCellFloatEditor,
23011 _swigc__p_wxGridCellFloatRenderer,
23012 _swigc__p_wxGridCellNumberEditor,
23013 _swigc__p_wxGridCellNumberRenderer,
23014 _swigc__p_wxGridCellRenderer,
23015 _swigc__p_wxGridCellStringRenderer,
23016 _swigc__p_wxGridCellTextEditor,
23017 _swigc__p_wxGridCellWorker,
23018 _swigc__p_wxGridEditorCreatedEvent,
23019 _swigc__p_wxGridEvent,
23020 _swigc__p_wxGridRangeSelectEvent,
23021 _swigc__p_wxGridSizeEvent,
23022 _swigc__p_wxGridSizer,
23023 _swigc__p_wxGridStringTable,
23024 _swigc__p_wxGridTableBase,
23025 _swigc__p_wxGridTableMessage,
23026 _swigc__p_wxGridUpdateLocker,
23027 _swigc__p_wxICOHandler,
23028 _swigc__p_wxIconizeEvent,
23029 _swigc__p_wxIdleEvent,
23030 _swigc__p_wxImage,
23031 _swigc__p_wxImageHandler,
23032 _swigc__p_wxIndividualLayoutConstraint,
23033 _swigc__p_wxInitDialogEvent,
23034 _swigc__p_wxJPEGHandler,
23035 _swigc__p_wxKeyEvent,
23036 _swigc__p_wxLayoutAlgorithm,
23037 _swigc__p_wxLayoutConstraints,
23038 _swigc__p_wxMDIChildFrame,
23039 _swigc__p_wxMDIClientWindow,
23040 _swigc__p_wxMDIParentFrame,
23041 _swigc__p_wxMaximizeEvent,
23042 _swigc__p_wxMenu,
23043 _swigc__p_wxMenuBar,
23044 _swigc__p_wxMenuEvent,
23045 _swigc__p_wxMenuItem,
23046 _swigc__p_wxMessageDialog,
23047 _swigc__p_wxMiniFrame,
23048 _swigc__p_wxMouseCaptureChangedEvent,
23049 _swigc__p_wxMouseCaptureLostEvent,
23050 _swigc__p_wxMouseEvent,
23051 _swigc__p_wxMoveEvent,
23052 _swigc__p_wxMultiChoiceDialog,
23053 _swigc__p_wxNavigationKeyEvent,
23054 _swigc__p_wxNcPaintEvent,
23055 _swigc__p_wxNotifyEvent,
23056 _swigc__p_wxNumberEntryDialog,
23057 _swigc__p_wxObject,
23058 _swigc__p_wxPCXHandler,
23059 _swigc__p_wxPNGHandler,
23060 _swigc__p_wxPNMHandler,
23061 _swigc__p_wxPageSetupDialog,
23062 _swigc__p_wxPageSetupDialogData,
23063 _swigc__p_wxPaintEvent,
23064 _swigc__p_wxPaletteChangedEvent,
23065 _swigc__p_wxPanel,
23066 _swigc__p_wxPaperSize,
23067 _swigc__p_wxPasswordEntryDialog,
23068 _swigc__p_wxPen,
23069 _swigc__p_wxPoint,
23070 _swigc__p_wxPopupWindow,
23071 _swigc__p_wxPreviewCanvas,
23072 _swigc__p_wxPreviewControlBar,
23073 _swigc__p_wxPreviewFrame,
23074 _swigc__p_wxPrintData,
23075 _swigc__p_wxPrintDialog,
23076 _swigc__p_wxPrintDialogData,
23077 _swigc__p_wxPrintPreview,
23078 _swigc__p_wxPrinter,
23079 _swigc__p_wxProgressDialog,
23080 _swigc__p_wxPyApp,
23081 _swigc__p_wxPyCommandEvent,
23082 _swigc__p_wxPyEvent,
23083 _swigc__p_wxPyGridCellAttrProvider,
23084 _swigc__p_wxPyGridCellEditor,
23085 _swigc__p_wxPyGridCellRenderer,
23086 _swigc__p_wxPyGridTableBase,
23087 _swigc__p_wxPyHtmlListBox,
23088 _swigc__p_wxPyImageHandler,
23089 _swigc__p_wxPyPanel,
23090 _swigc__p_wxPyPopupTransientWindow,
23091 _swigc__p_wxPyPreviewControlBar,
23092 _swigc__p_wxPyPreviewFrame,
23093 _swigc__p_wxPyPrintPreview,
23094 _swigc__p_wxPyPrintout,
23095 _swigc__p_wxPyScrolledWindow,
23096 _swigc__p_wxPySizer,
23097 _swigc__p_wxPyTaskBarIcon,
23098 _swigc__p_wxPyVListBox,
23099 _swigc__p_wxPyVScrolledWindow,
23100 _swigc__p_wxPyValidator,
23101 _swigc__p_wxPyWindow,
23102 _swigc__p_wxQueryLayoutInfoEvent,
23103 _swigc__p_wxQueryNewPaletteEvent,
23104 _swigc__p_wxRect,
23105 _swigc__p_wxSashEvent,
23106 _swigc__p_wxSashLayoutWindow,
23107 _swigc__p_wxSashWindow,
23108 _swigc__p_wxScrollEvent,
23109 _swigc__p_wxScrollWinEvent,
23110 _swigc__p_wxScrolledWindow,
23111 _swigc__p_wxSetCursorEvent,
23112 _swigc__p_wxShowEvent,
23113 _swigc__p_wxSimpleHtmlListBox,
23114 _swigc__p_wxSingleChoiceDialog,
23115 _swigc__p_wxSize,
23116 _swigc__p_wxSizeEvent,
23117 _swigc__p_wxSizer,
23118 _swigc__p_wxSizerItem,
23119 _swigc__p_wxSplashScreen,
23120 _swigc__p_wxSplashScreenWindow,
23121 _swigc__p_wxSplitterEvent,
23122 _swigc__p_wxSplitterWindow,
23123 _swigc__p_wxStaticBoxSizer,
23124 _swigc__p_wxStatusBar,
23125 _swigc__p_wxStdDialogButtonSizer,
23126 _swigc__p_wxString,
23127 _swigc__p_wxSysColourChangedEvent,
23128 _swigc__p_wxTGAHandler,
23129 _swigc__p_wxTIFFHandler,
23130 _swigc__p_wxTaskBarIconEvent,
23131 _swigc__p_wxTextEntryDialog,
23132 _swigc__p_wxTipWindow,
23133 _swigc__p_wxTopLevelWindow,
23134 _swigc__p_wxUpdateUIEvent,
23135 _swigc__p_wxValidator,
23136 _swigc__p_wxVisualAttributes,
23137 _swigc__p_wxWindow,
23138 _swigc__p_wxWindowCreateEvent,
23139 _swigc__p_wxWindowDestroyEvent,
23140 _swigc__p_wxXPMHandler,
23141 };
23142
23143
23144 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23145
23146 static swig_const_info swig_const_table[] = {
23147 {0, 0, 0, 0.0, 0, 0}};
23148
23149 #ifdef __cplusplus
23150 }
23151 #endif
23152 /* -----------------------------------------------------------------------------
23153 * Type initialization:
23154 * This problem is tough by the requirement that no dynamic
23155 * memory is used. Also, since swig_type_info structures store pointers to
23156 * swig_cast_info structures and swig_cast_info structures store pointers back
23157 * to swig_type_info structures, we need some lookup code at initialization.
23158 * The idea is that swig generates all the structures that are needed.
23159 * The runtime then collects these partially filled structures.
23160 * The SWIG_InitializeModule function takes these initial arrays out of
23161 * swig_module, and does all the lookup, filling in the swig_module.types
23162 * array with the correct data and linking the correct swig_cast_info
23163 * structures together.
23164 *
23165 * The generated swig_type_info structures are assigned staticly to an initial
23166 * array. We just loop though that array, and handle each type individually.
23167 * First we lookup if this type has been already loaded, and if so, use the
23168 * loaded structure instead of the generated one. Then we have to fill in the
23169 * cast linked list. The cast data is initially stored in something like a
23170 * two-dimensional array. Each row corresponds to a type (there are the same
23171 * number of rows as there are in the swig_type_initial array). Each entry in
23172 * a column is one of the swig_cast_info structures for that type.
23173 * The cast_initial array is actually an array of arrays, because each row has
23174 * a variable number of columns. So to actually build the cast linked list,
23175 * we find the array of casts associated with the type, and loop through it
23176 * adding the casts to the list. The one last trick we need to do is making
23177 * sure the type pointer in the swig_cast_info struct is correct.
23178 *
23179 * First off, we lookup the cast->type name to see if it is already loaded.
23180 * There are three cases to handle:
23181 * 1) If the cast->type has already been loaded AND the type we are adding
23182 * casting info to has not been loaded (it is in this module), THEN we
23183 * replace the cast->type pointer with the type pointer that has already
23184 * been loaded.
23185 * 2) If BOTH types (the one we are adding casting info to, and the
23186 * cast->type) are loaded, THEN the cast info has already been loaded by
23187 * the previous module so we just ignore it.
23188 * 3) Finally, if cast->type has not already been loaded, then we add that
23189 * swig_cast_info to the linked list (because the cast->type) pointer will
23190 * be correct.
23191 * ----------------------------------------------------------------------------- */
23192
23193 #ifdef __cplusplus
23194 extern "C" {
23195 #if 0
23196 } /* c-mode */
23197 #endif
23198 #endif
23199
23200 #if 0
23201 #define SWIGRUNTIME_DEBUG
23202 #endif
23203
23204 SWIGRUNTIME void
23205 SWIG_InitializeModule(void *clientdata) {
23206 size_t i;
23207 swig_module_info *module_head;
23208 static int init_run = 0;
23209
23210 clientdata = clientdata;
23211
23212 if (init_run) return;
23213 init_run = 1;
23214
23215 /* Initialize the swig_module */
23216 swig_module.type_initial = swig_type_initial;
23217 swig_module.cast_initial = swig_cast_initial;
23218
23219 /* Try and load any already created modules */
23220 module_head = SWIG_GetModule(clientdata);
23221 if (module_head) {
23222 swig_module.next = module_head->next;
23223 module_head->next = &swig_module;
23224 } else {
23225 /* This is the first module loaded */
23226 swig_module.next = &swig_module;
23227 SWIG_SetModule(clientdata, &swig_module);
23228 }
23229
23230 /* Now work on filling in swig_module.types */
23231 #ifdef SWIGRUNTIME_DEBUG
23232 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23233 #endif
23234 for (i = 0; i < swig_module.size; ++i) {
23235 swig_type_info *type = 0;
23236 swig_type_info *ret;
23237 swig_cast_info *cast;
23238
23239 #ifdef SWIGRUNTIME_DEBUG
23240 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23241 #endif
23242
23243 /* if there is another module already loaded */
23244 if (swig_module.next != &swig_module) {
23245 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23246 }
23247 if (type) {
23248 /* Overwrite clientdata field */
23249 #ifdef SWIGRUNTIME_DEBUG
23250 printf("SWIG_InitializeModule: found type %s\n", type->name);
23251 #endif
23252 if (swig_module.type_initial[i]->clientdata) {
23253 type->clientdata = swig_module.type_initial[i]->clientdata;
23254 #ifdef SWIGRUNTIME_DEBUG
23255 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23256 #endif
23257 }
23258 } else {
23259 type = swig_module.type_initial[i];
23260 }
23261
23262 /* Insert casting types */
23263 cast = swig_module.cast_initial[i];
23264 while (cast->type) {
23265 /* Don't need to add information already in the list */
23266 ret = 0;
23267 #ifdef SWIGRUNTIME_DEBUG
23268 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23269 #endif
23270 if (swig_module.next != &swig_module) {
23271 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23272 #ifdef SWIGRUNTIME_DEBUG
23273 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23274 #endif
23275 }
23276 if (ret) {
23277 if (type == swig_module.type_initial[i]) {
23278 #ifdef SWIGRUNTIME_DEBUG
23279 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23280 #endif
23281 cast->type = ret;
23282 ret = 0;
23283 } else {
23284 /* Check for casting already in the list */
23285 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23286 #ifdef SWIGRUNTIME_DEBUG
23287 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23288 #endif
23289 if (!ocast) ret = 0;
23290 }
23291 }
23292
23293 if (!ret) {
23294 #ifdef SWIGRUNTIME_DEBUG
23295 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23296 #endif
23297 if (type->cast) {
23298 type->cast->prev = cast;
23299 cast->next = type->cast;
23300 }
23301 type->cast = cast;
23302 }
23303 cast++;
23304 }
23305 /* Set entry in modules->types array equal to the type */
23306 swig_module.types[i] = type;
23307 }
23308 swig_module.types[i] = 0;
23309
23310 #ifdef SWIGRUNTIME_DEBUG
23311 printf("**** SWIG_InitializeModule: Cast List ******\n");
23312 for (i = 0; i < swig_module.size; ++i) {
23313 int j = 0;
23314 swig_cast_info *cast = swig_module.cast_initial[i];
23315 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23316 while (cast->type) {
23317 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23318 cast++;
23319 ++j;
23320 }
23321 printf("---- Total casts: %d\n",j);
23322 }
23323 printf("**** SWIG_InitializeModule: Cast List ******\n");
23324 #endif
23325 }
23326
23327 /* This function will propagate the clientdata field of type to
23328 * any new swig_type_info structures that have been added into the list
23329 * of equivalent types. It is like calling
23330 * SWIG_TypeClientData(type, clientdata) a second time.
23331 */
23332 SWIGRUNTIME void
23333 SWIG_PropagateClientData(void) {
23334 size_t i;
23335 swig_cast_info *equiv;
23336 static int init_run = 0;
23337
23338 if (init_run) return;
23339 init_run = 1;
23340
23341 for (i = 0; i < swig_module.size; i++) {
23342 if (swig_module.types[i]->clientdata) {
23343 equiv = swig_module.types[i]->cast;
23344 while (equiv) {
23345 if (!equiv->converter) {
23346 if (equiv->type && !equiv->type->clientdata)
23347 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23348 }
23349 equiv = equiv->next;
23350 }
23351 }
23352 }
23353 }
23354
23355 #ifdef __cplusplus
23356 #if 0
23357 {
23358 /* c-mode */
23359 #endif
23360 }
23361 #endif
23362
23363
23364
23365 #ifdef __cplusplus
23366 extern "C" {
23367 #endif
23368
23369 /* Python-specific SWIG API */
23370 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23371 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23372 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23373
23374 /* -----------------------------------------------------------------------------
23375 * global variable support code.
23376 * ----------------------------------------------------------------------------- */
23377
23378 typedef struct swig_globalvar {
23379 char *name; /* Name of global variable */
23380 PyObject *(*get_attr)(void); /* Return the current value */
23381 int (*set_attr)(PyObject *); /* Set the value */
23382 struct swig_globalvar *next;
23383 } swig_globalvar;
23384
23385 typedef struct swig_varlinkobject {
23386 PyObject_HEAD
23387 swig_globalvar *vars;
23388 } swig_varlinkobject;
23389
23390 SWIGINTERN PyObject *
23391 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23392 return PyString_FromString("<Swig global variables>");
23393 }
23394
23395 SWIGINTERN PyObject *
23396 swig_varlink_str(swig_varlinkobject *v) {
23397 PyObject *str = PyString_FromString("(");
23398 swig_globalvar *var;
23399 for (var = v->vars; var; var=var->next) {
23400 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23401 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23402 }
23403 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23404 return str;
23405 }
23406
23407 SWIGINTERN int
23408 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23409 PyObject *str = swig_varlink_str(v);
23410 fprintf(fp,"Swig global variables ");
23411 fprintf(fp,"%s\n", PyString_AsString(str));
23412 Py_DECREF(str);
23413 return 0;
23414 }
23415
23416 SWIGINTERN void
23417 swig_varlink_dealloc(swig_varlinkobject *v) {
23418 swig_globalvar *var = v->vars;
23419 while (var) {
23420 swig_globalvar *n = var->next;
23421 free(var->name);
23422 free(var);
23423 var = n;
23424 }
23425 }
23426
23427 SWIGINTERN PyObject *
23428 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23429 PyObject *res = NULL;
23430 swig_globalvar *var = v->vars;
23431 while (var) {
23432 if (strcmp(var->name,n) == 0) {
23433 res = (*var->get_attr)();
23434 break;
23435 }
23436 var = var->next;
23437 }
23438 if (res == NULL && !PyErr_Occurred()) {
23439 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23440 }
23441 return res;
23442 }
23443
23444 SWIGINTERN int
23445 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23446 int res = 1;
23447 swig_globalvar *var = v->vars;
23448 while (var) {
23449 if (strcmp(var->name,n) == 0) {
23450 res = (*var->set_attr)(p);
23451 break;
23452 }
23453 var = var->next;
23454 }
23455 if (res == 1 && !PyErr_Occurred()) {
23456 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23457 }
23458 return res;
23459 }
23460
23461 SWIGINTERN PyTypeObject*
23462 swig_varlink_type(void) {
23463 static char varlink__doc__[] = "Swig var link object";
23464 static PyTypeObject varlink_type;
23465 static int type_init = 0;
23466 if (!type_init) {
23467 const PyTypeObject tmp
23468 = {
23469 PyObject_HEAD_INIT(NULL)
23470 0, /* Number of items in variable part (ob_size) */
23471 (char *)"swigvarlink", /* Type name (tp_name) */
23472 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23473 0, /* Itemsize (tp_itemsize) */
23474 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23475 (printfunc) swig_varlink_print, /* Print (tp_print) */
23476 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23477 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23478 0, /* tp_compare */
23479 (reprfunc) swig_varlink_repr, /* tp_repr */
23480 0, /* tp_as_number */
23481 0, /* tp_as_sequence */
23482 0, /* tp_as_mapping */
23483 0, /* tp_hash */
23484 0, /* tp_call */
23485 (reprfunc)swig_varlink_str, /* tp_str */
23486 0, /* tp_getattro */
23487 0, /* tp_setattro */
23488 0, /* tp_as_buffer */
23489 0, /* tp_flags */
23490 varlink__doc__, /* tp_doc */
23491 0, /* tp_traverse */
23492 0, /* tp_clear */
23493 0, /* tp_richcompare */
23494 0, /* tp_weaklistoffset */
23495 #if PY_VERSION_HEX >= 0x02020000
23496 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23497 #endif
23498 #if PY_VERSION_HEX >= 0x02030000
23499 0, /* tp_del */
23500 #endif
23501 #ifdef COUNT_ALLOCS
23502 0,0,0,0 /* tp_alloc -> tp_next */
23503 #endif
23504 };
23505 varlink_type = tmp;
23506 varlink_type.ob_type = &PyType_Type;
23507 type_init = 1;
23508 }
23509 return &varlink_type;
23510 }
23511
23512 /* Create a variable linking object for use later */
23513 SWIGINTERN PyObject *
23514 SWIG_Python_newvarlink(void) {
23515 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23516 if (result) {
23517 result->vars = 0;
23518 }
23519 return ((PyObject*) result);
23520 }
23521
23522 SWIGINTERN void
23523 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23524 swig_varlinkobject *v = (swig_varlinkobject *) p;
23525 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23526 if (gv) {
23527 size_t size = strlen(name)+1;
23528 gv->name = (char *)malloc(size);
23529 if (gv->name) {
23530 strncpy(gv->name,name,size);
23531 gv->get_attr = get_attr;
23532 gv->set_attr = set_attr;
23533 gv->next = v->vars;
23534 }
23535 }
23536 v->vars = gv;
23537 }
23538
23539 SWIGINTERN PyObject *
23540 SWIG_globals() {
23541 static PyObject *_SWIG_globals = 0;
23542 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23543 return _SWIG_globals;
23544 }
23545
23546 /* -----------------------------------------------------------------------------
23547 * constants/methods manipulation
23548 * ----------------------------------------------------------------------------- */
23549
23550 /* Install Constants */
23551 SWIGINTERN void
23552 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23553 PyObject *obj = 0;
23554 size_t i;
23555 for (i = 0; constants[i].type; ++i) {
23556 switch(constants[i].type) {
23557 case SWIG_PY_POINTER:
23558 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23559 break;
23560 case SWIG_PY_BINARY:
23561 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23562 break;
23563 default:
23564 obj = 0;
23565 break;
23566 }
23567 if (obj) {
23568 PyDict_SetItemString(d, constants[i].name, obj);
23569 Py_DECREF(obj);
23570 }
23571 }
23572 }
23573
23574 /* -----------------------------------------------------------------------------*/
23575 /* Fix SwigMethods to carry the callback ptrs when needed */
23576 /* -----------------------------------------------------------------------------*/
23577
23578 SWIGINTERN void
23579 SWIG_Python_FixMethods(PyMethodDef *methods,
23580 swig_const_info *const_table,
23581 swig_type_info **types,
23582 swig_type_info **types_initial) {
23583 size_t i;
23584 for (i = 0; methods[i].ml_name; ++i) {
23585 const char *c = methods[i].ml_doc;
23586 if (c && (c = strstr(c, "swig_ptr: "))) {
23587 int j;
23588 swig_const_info *ci = 0;
23589 const char *name = c + 10;
23590 for (j = 0; const_table[j].type; ++j) {
23591 if (strncmp(const_table[j].name, name,
23592 strlen(const_table[j].name)) == 0) {
23593 ci = &(const_table[j]);
23594 break;
23595 }
23596 }
23597 if (ci) {
23598 size_t shift = (ci->ptype) - types;
23599 swig_type_info *ty = types_initial[shift];
23600 size_t ldoc = (c - methods[i].ml_doc);
23601 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23602 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23603 if (ndoc) {
23604 char *buff = ndoc;
23605 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23606 if (ptr) {
23607 strncpy(buff, methods[i].ml_doc, ldoc);
23608 buff += ldoc;
23609 strncpy(buff, "swig_ptr: ", 10);
23610 buff += 10;
23611 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23612 methods[i].ml_doc = ndoc;
23613 }
23614 }
23615 }
23616 }
23617 }
23618 }
23619
23620 #ifdef __cplusplus
23621 }
23622 #endif
23623
23624 /* -----------------------------------------------------------------------------*
23625 * Partial Init method
23626 * -----------------------------------------------------------------------------*/
23627
23628 #ifdef __cplusplus
23629 extern "C"
23630 #endif
23631 SWIGEXPORT void SWIG_init(void) {
23632 PyObject *m, *d;
23633
23634 /* Fix SwigMethods to carry the callback ptrs when needed */
23635 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23636
23637 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23638 d = PyModule_GetDict(m);
23639
23640 SWIG_InitializeModule(0);
23641 SWIG_InstallConstants(d,swig_const_table);
23642
23643
23644 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23645 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23646 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23647 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23648 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23649 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23650 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23651 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23652 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23653 SWIG_Python_SetConstant(d, "GRID_AUTOSIZE",SWIG_From_int(static_cast< int >(wxGRID_AUTOSIZE)));
23654 SWIG_Python_SetConstant(d, "GRID_COLUMN",SWIG_From_int(static_cast< int >(wxGRID_COLUMN)));
23655 SWIG_Python_SetConstant(d, "GRID_ROW",SWIG_From_int(static_cast< int >(wxGRID_ROW)));
23656 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23657 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23658 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23659 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23660 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23661 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23662 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23663 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23664 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23665 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23666 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23667 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23668 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23669 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23670 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23671 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23672 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23673 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23674 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23675 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23676 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23677 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23678 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23679 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23680 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23681 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23682 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23683 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23684 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23685 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23686 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23687 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23688 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23689 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23690 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23691 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23692 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23693 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23694 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23695 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23696 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23697 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23698 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23699 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23700 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23701 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23702 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23703 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23704
23705
23706 }
23707
wxWidgets (Impactor)