wxPython/src/msw/grid.cpp

   1 /*
   2  * FILE : src/msw/grid.cpp
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Build 883)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PYTHON */
  20
  21 #define SWIGPYTHON
  22 #include <string.h>
  23 #include <stdlib.h>
  24 /* Definitions for Windows/Unix exporting */
  25 #if defined(__WIN32__)
  26 #   if defined(_MSC_VER)
  27 #       define SWIGEXPORT(a) __declspec(dllexport) a
  28 #   else
  29 #       if defined(__BORLANDC__)
  30 #           define SWIGEXPORT(a) a _export
  31 #       else
  32 #           define SWIGEXPORT(a) a
  33 #       endif
  34 #   endif
  35 #else
  36 #   define SWIGEXPORT(a) a
  37 #endif
  38
  39 #include "Python.h"
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 extern void SWIG_MakePtr(char *, void *, char *);
  46 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
  47 extern char *SWIG_GetPtr(char *, void **, char *);
  48 extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
  49 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
  50 extern PyObject *SWIG_newvarlink(void);
  51 #ifdef __cplusplus
  52 }
  53 #endif
  54 #define SWIG_init    initgridc
  55
  56 #define SWIG_name    "gridc"
  57
  58 #include "export.h"
  59 #include <wx/grid.h>
  60 #include <wx/generic/gridctrl.h>
  61
  62
  63 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  64     PyObject*   o2;
  65     PyObject*   o3;
  66
  67     if (!target) {
  68         target = o;
  69     } else if (target == Py_None) {
  70         Py_DECREF(Py_None);
  71         target = o;
  72     } else {
  73         if (!PyTuple_Check(target)) {
  74             o2 = target;
  75             target = PyTuple_New(1);
  76             PyTuple_SetItem(target, 0, o2);
  77         }
  78         o3 = PyTuple_New(1);
  79         PyTuple_SetItem(o3, 0, o);
  80
  81         o2 = target;
  82         target = PySequence_Concat(o2, o3);
  83         Py_DECREF(o2);
  84         Py_DECREF(o3);
  85     }
  86     return target;
  87 }
  88
  89 #if PYTHON_API_VERSION >= 1009
  90     static char* wxStringErrorMsg = "String or Unicode type required";
  91 #else
  92     static char* wxStringErrorMsg = "String type required";
  93 #endif
  94
  95 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
  96     wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
  97         wxGridCellAttr* rval = NULL;                                            \
  98         bool found;                                                             \
  99         wxPyTState* state = wxPyBeginBlockThreads();                            \
 100         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 101             PyObject* ro;                                                       \
 102             wxGridCellAttr* ptr;                                                \
 103             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
 104             if (ro) {                                                           \
 105                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p"))    \
 106                     rval = ptr;                                                 \
 107                 Py_DECREF(ro);                                                  \
 108             }                                                                   \
 109         }                                                                       \
 110         wxPyEndBlockThreads(state);                                             \
 111         if (! found)                                                            \
 112             rval = PCLASS::CBNAME(a, b, c);                                     \
 113         return rval;                                                            \
 114     }                                                                           \
 115     wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
 116         return PCLASS::CBNAME(a, b, c);                                         \
 117     }
 118
 119
 120
 121 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
 122     void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
 123         wxPyTState* state = wxPyBeginBlockThreads();                            \
 124         bool found;                                                             \
 125         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 126             PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
 127             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));   \
 128             Py_DECREF(obj);                                                     \
 129         }                                                                       \
 130         wxPyEndBlockThreads(state);                                             \
 131         if (! found)                                                            \
 132             PCLASS::CBNAME(attr, a, b);                                         \
 133     }                                                                           \
 134     void base_##CBNAME(wxGridCellAttr *attr, int a, int b) {                    \
 135         PCLASS::CBNAME(attr, a, b);                                             \
 136     }
 137
 138
 139
 140 #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
 141     void CBNAME(wxGridCellAttr *attr, int val) {                                \
 142         wxPyTState* state = wxPyBeginBlockThreads();                            \
 143         bool found;                                                             \
 144         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 145             PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
 146             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
 147             Py_DECREF(obj);                                                     \
 148         }                                                                       \
 149         wxPyEndBlockThreads(state);                                             \
 150         if (! found)                                                            \
 151             PCLASS::CBNAME(attr, val);                                          \
 152     }                                                                           \
 153     void base_##CBNAME(wxGridCellAttr *attr, int val) {                         \
 154         PCLASS::CBNAME(attr, val);                                              \
 155     }
 156
 157
 158
 159 #define PYCALLBACK_INT__pure(CBNAME)                                            \
 160     int  CBNAME() {                                                             \
 161         wxPyTState* state = wxPyBeginBlockThreads();                            \
 162         int rval = 0;                                                           \
 163         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 164             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 165         wxPyEndBlockThreads(state);                                             \
 166         return rval;                                                            \
 167     }
 168
 169
 170
 171 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
 172     bool CBNAME(int a, int b) {                                                 \
 173         wxPyTState* state = wxPyBeginBlockThreads();                            \
 174         bool rval = 0;                                                          \
 175         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 176             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
 177         wxPyEndBlockThreads(state);                                             \
 178         return rval;                                                            \
 179     }
 180
 181
 182
 183 #define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
 184     wxString CBNAME(int a, int b) {                                             \
 185         wxPyTState* state = wxPyBeginBlockThreads();                            \
 186         wxString rval;                                                          \
 187         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 188             PyObject* ro;                                                       \
 189             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 190             if (ro) {                                                           \
 191                 PyObject* str = PyObject_Str(ro);                               \
 192                 rval = PyString_AsString(str);                                  \
 193                 Py_DECREF(ro);  Py_DECREF(str);                                 \
 194             }                                                                   \
 195         }                                                                       \
 196         wxPyEndBlockThreads(state);                                             \
 197         return rval;                                                            \
 198     }
 199
 200
 201
 202 #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
 203     void CBNAME(int a, int b, const wxString& c) {                              \
 204         wxPyTState* state = wxPyBeginBlockThreads();                            \
 205         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 206             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
 207         wxPyEndBlockThreads(state);                                             \
 208     }
 209
 210
 211 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
 212     wxString CBNAME(int a, int b) {                                             \
 213         bool found;                                                             \
 214         wxPyTState* state = wxPyBeginBlockThreads();                            \
 215         wxString rval;                                                          \
 216         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 217             PyObject* ro;                                                       \
 218             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 219             if (ro) {                                                           \
 220                 PyObject* str = PyObject_Str(ro);                               \
 221                 rval = PyString_AsString(str);                                  \
 222                 Py_DECREF(ro);  Py_DECREF(str);                                 \
 223             }                                                                   \
 224         }                                                                       \
 225         wxPyEndBlockThreads(state);                                             \
 226         if (! found)                                                            \
 227             rval = PCLASS::CBNAME(a, b);                                        \
 228         return rval;                                                            \
 229     }                                                                           \
 230     wxString base_##CBNAME(int a, int b) {                                      \
 231         return PCLASS::CBNAME(a, b);                                            \
 232     }
 233
 234
 235
 236 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
 237     bool CBNAME(int a, int b, const wxString& c)  {                             \
 238         bool rval = 0;                                                          \
 239         bool found;                                                             \
 240         wxPyTState* state = wxPyBeginBlockThreads();                            \
 241         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 242             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str()));\
 243         wxPyEndBlockThreads(state);                                             \
 244         if (! found)                                                            \
 245             rval = PCLASS::CBNAME(a,b,c);                                       \
 246         return rval;                                                            \
 247     }                                                                           \
 248     bool base_##CBNAME(int a, int b, const wxString& c) {                       \
 249         return PCLASS::CBNAME(a,b,c);                                           \
 250     }
 251
 252
 253
 254
 255 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME)                                  \
 256     long CBNAME(int a, int b)  {                                                \
 257         long rval;                                                              \
 258         bool found;                                                             \
 259         wxPyTState* state = wxPyBeginBlockThreads();                            \
 260         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 261             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 262         wxPyEndBlockThreads(state);                                             \
 263         if (! found)                                                            \
 264             rval = PCLASS::CBNAME(a,b);                                         \
 265         return rval;                                                            \
 266     }                                                                           \
 267     long base_##CBNAME(int a, int b) {                                          \
 268         return PCLASS::CBNAME(a,b);                                             \
 269     }
 270
 271
 272
 273 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
 274     bool CBNAME(int a, int b)  {                                                \
 275         bool rval = 0;                                                          \
 276         bool found;                                                             \
 277         wxPyTState* state = wxPyBeginBlockThreads();                            \
 278         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 279             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 280         wxPyEndBlockThreads(state);                                             \
 281         if (! found)                                                            \
 282             rval = PCLASS::CBNAME(a,b);                                         \
 283         return rval;                                                            \
 284     }                                                                           \
 285     bool base_##CBNAME(int a, int b) {                                          \
 286         return PCLASS::CBNAME(a,b);                                             \
 287     }
 288
 289
 290
 291 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
 292     double CBNAME(int a, int b) {                                               \
 293         bool found;                                                             \
 294         wxPyTState* state = wxPyBeginBlockThreads();                            \
 295         double rval;                                                            \
 296         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 297             PyObject* ro;                                                       \
 298             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 299             if (ro) {                                                           \
 300                 PyObject* str = PyObject_Str(ro);                               \
 301                 rval = PyFloat_AsDouble(str);                                   \
 302                 Py_DECREF(ro);   Py_DECREF(str);                                \
 303             }                                                                   \
 304         }                                                                       \
 305         wxPyEndBlockThreads(state);                                             \
 306         if (! found)                                                            \
 307             rval = PCLASS::CBNAME(a, b);                                        \
 308         return rval;                                                            \
 309     }                                                                           \
 310     double base_##CBNAME(int a, int b) {                                        \
 311         return PCLASS::CBNAME(a, b);                                            \
 312     }
 313
 314
 315
 316 #define PYCALLBACK__(PCLASS, CBNAME)                                            \
 317     void CBNAME()  {                                                            \
 318         bool found;                                                             \
 319         wxPyTState* state = wxPyBeginBlockThreads();                            \
 320         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 321             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
 322         wxPyEndBlockThreads(state);                                             \
 323         if (! found)                                                            \
 324             PCLASS::CBNAME();                                                   \
 325     }                                                                           \
 326     void base_##CBNAME() {                                                      \
 327         PCLASS::CBNAME();                                                       \
 328     }
 329
 330
 331
 332
 333 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
 334     bool CBNAME(size_t a, size_t b)  {                                          \
 335         bool rval = 0;                                                          \
 336         bool found;                                                             \
 337         wxPyTState* state = wxPyBeginBlockThreads();                            \
 338         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 339             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 340         wxPyEndBlockThreads(state);                                             \
 341         if (! found)                                                            \
 342             rval = PCLASS::CBNAME(a,b);                                         \
 343         return rval;                                                            \
 344     }                                                                           \
 345     bool base_##CBNAME(size_t a, size_t b) {                                    \
 346         return PCLASS::CBNAME(a,b);                                             \
 347     }
 348
 349
 350
 351 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
 352     bool CBNAME(size_t a)  {                                                    \
 353         bool rval = 0;                                                          \
 354         bool found;                                                             \
 355         wxPyTState* state = wxPyBeginBlockThreads();                            \
 356         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 357             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
 358         wxPyEndBlockThreads(state);                                             \
 359         if (! found)                                                            \
 360             rval = PCLASS::CBNAME(a);                                           \
 361         return rval;                                                            \
 362     }                                                                           \
 363     bool base_##CBNAME(size_t a) {                                              \
 364         return PCLASS::CBNAME(a);                                               \
 365     }
 366
 367
 368
 369 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
 370     wxString CBNAME(int a) {                                                    \
 371         bool found;                                                             \
 372         wxPyTState* state = wxPyBeginBlockThreads();                            \
 373         wxString rval;                                                          \
 374         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 375             PyObject* ro;                                                       \
 376             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
 377             if (ro) {                                                           \
 378                 PyObject* str = PyObject_Str(ro);                               \
 379                 rval = PyString_AsString(str);                                  \
 380                 Py_DECREF(ro);   Py_DECREF(str);                                \
 381             }                                                                   \
 382         }                                                                       \
 383         wxPyEndBlockThreads(state);                                             \
 384         if (! found)                                                            \
 385             rval = PCLASS::CBNAME(a);                                           \
 386         return rval;                                                            \
 387     }                                                                           \
 388     wxString base_##CBNAME(int a) {                                             \
 389         return PCLASS::CBNAME(a);                                               \
 390     }
 391
 392
 393
 394 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
 395     void CBNAME(int a, const wxString& c)  {                                    \
 396         bool found;                                                             \
 397         wxPyTState* state = wxPyBeginBlockThreads();                            \
 398         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 399             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str())); \
 400         wxPyEndBlockThreads(state);                                             \
 401         if (! found)                                                            \
 402             PCLASS::CBNAME(a,c);                                                \
 403     }                                                                           \
 404     void base_##CBNAME(int a, const wxString& c) {                              \
 405         PCLASS::CBNAME(a,c);                                                    \
 406     }
 407
 408
 409
 410
 411 #define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
 412     bool CBNAME()  {                                                            \
 413         bool rval = 0;                                                          \
 414         bool found;                                                             \
 415         wxPyTState* state = wxPyBeginBlockThreads();                            \
 416         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 417             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 418         wxPyEndBlockThreads(state);                                             \
 419         if (! found)                                                            \
 420             rval = PCLASS::CBNAME();                                            \
 421         return rval;                                                            \
 422     }                                                                           \
 423     bool base_##CBNAME() {                                                      \
 424         return PCLASS::CBNAME();                                                \
 425     }
 426
 427
 428
 429 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
 430     void CBNAME(size_t a, int b)  {                                             \
 431         bool found;                                                             \
 432         wxPyTState* state = wxPyBeginBlockThreads();                            \
 433         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 434             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
 435         wxPyEndBlockThreads(state);                                             \
 436         if (! found)                                                            \
 437             PCLASS::CBNAME(a,b);                                                \
 438     }                                                                           \
 439     void base_##CBNAME(size_t a, int b) {                                       \
 440         PCLASS::CBNAME(a,b);                                                    \
 441     }
 442
 443
 444
 445
 446 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
 447     void CBNAME(int a, int b, long c)  {                                        \
 448         bool found;                                                             \
 449         wxPyTState* state = wxPyBeginBlockThreads();                            \
 450         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 451             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 452         wxPyEndBlockThreads(state);                                             \
 453         if (! found)                                                            \
 454             PCLASS::CBNAME(a,b,c);                                              \
 455     }                                                                           \
 456     void base_##CBNAME(int a, int b, long c) {                                  \
 457         PCLASS::CBNAME(a,b,c);                                                  \
 458     }
 459
 460
 461
 462
 463 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
 464     void CBNAME(int a, int b, double c)  {                                      \
 465         bool found;                                                             \
 466         wxPyTState* state = wxPyBeginBlockThreads();                            \
 467         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 468             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
 469         wxPyEndBlockThreads(state);                                             \
 470         if (! found)                                                            \
 471             PCLASS::CBNAME(a,b,c);                                              \
 472     }                                                                           \
 473     void base_##CBNAME(int a, int b, double c) {                                \
 474         PCLASS::CBNAME(a,b,c);                                                  \
 475     }
 476
 477
 478
 479 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
 480     void CBNAME(int a, int b, bool c)  {                                        \
 481         bool found;                                                             \
 482         wxPyTState* state = wxPyBeginBlockThreads();                            \
 483         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 484             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 485         wxPyEndBlockThreads(state);                                             \
 486         if (! found)                                                            \
 487             PCLASS::CBNAME(a,b,c);                                              \
 488     }                                                                           \
 489     void base_##CBNAME(int a, int b, bool c) {                                  \
 490         PCLASS::CBNAME(a,b,c);                                                  \
 491     }
 492
 493
 494
 495
 496
 497 class wxPyGridCellRenderer : public wxGridCellRenderer
 498 {
 499 public:
 500     wxPyGridCellRenderer() : wxGridCellRenderer() {};
 501
 502     // Implement Python callback aware virtual methods
 503     void Draw(wxGrid& grid, wxGridCellAttr& attr,
 504               wxDC& dc, const wxRect& rect,
 505               int row, int col, bool isSelected) {
 506         wxPyTState* state = wxPyBeginBlockThreads();
 507         if (wxPyCBH_findCallback(m_myInst, "Draw")) {
 508             wxPyCBH_callCallback(m_myInst,
 509                 Py_BuildValue("(OOOOiii)",
 510                               wxPyConstructObject((void*)&grid, "wxGrid", 0),
 511                               wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
 512                               wxPyConstructObject((void*)&dc,   "wxDC", 0),
 513                               wxPyConstructObject((void*)&rect, "wxRect", 0),
 514                               row, col, isSelected));
 515         }
 516         wxPyEndBlockThreads(state);
 517     }
 518
 519     wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
 520                        int row, int col) {
 521         wxSize rval;
 522         wxPyTState* state = wxPyBeginBlockThreads();
 523         if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
 524             PyObject* ro;
 525             wxSize*   ptr;
 526             ro = wxPyCBH_callCallbackObj(m_myInst,
 527                 Py_BuildValue("(OOOii)",
 528                               wxPyConstructObject((void*)&grid, "wxGrid", 0),
 529                               wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
 530                               wxPyConstructObject((void*)&dc,   "wxDC", 0),
 531                               row, col));
 532             if (ro) {
 533                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
 534                     rval = *ptr;
 535                 Py_DECREF(ro);
 536             }
 537         }
 538         wxPyEndBlockThreads(state);
 539         return rval;
 540     }
 541
 542
 543     wxGridCellRenderer *Clone() const {
 544         wxGridCellRenderer* rval = NULL;
 545         wxPyTState* state = wxPyBeginBlockThreads();
 546         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 547             PyObject* ro;
 548             wxGridCellRenderer* ptr;
 549             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 550             if (ro) {
 551                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
 552                     rval = ptr;
 553                 Py_DECREF(ro);
 554             }
 555         }
 556         wxPyEndBlockThreads(state);
 557         return rval;
 558     }
 559
 560     DEC_PYCALLBACK__STRING(SetParameters);
 561
 562     PYPRIVATE;
 563 };
 564
 565 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
 566
 567
 568 class wxPyGridCellEditor : public wxGridCellEditor
 569 {
 570 public:
 571     wxPyGridCellEditor() : wxGridCellEditor() {}
 572
 573     void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
 574         wxPyTState* state = wxPyBeginBlockThreads();
 575         if (wxPyCBH_findCallback(m_myInst, "Create")) {
 576             wxPyCBH_callCallback(m_myInst,
 577                 Py_BuildValue("(OiO)",
 578                               wxPyConstructObject((void*)parent, "wxWindow", 0),
 579                               id,
 580                               wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
 581         }
 582         wxPyEndBlockThreads(state);
 583     }
 584
 585
 586     void BeginEdit(int row, int col, wxGrid* grid) {
 587         wxPyTState* state = wxPyBeginBlockThreads();
 588         if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
 589             wxPyCBH_callCallback(m_myInst,
 590                 Py_BuildValue("(iiO)", row, col,
 591                               wxPyConstructObject((void*)grid, "wxGrid", 0)));
 592         }
 593         wxPyEndBlockThreads(state);
 594     }
 595
 596
 597     bool EndEdit(int row, int col, wxGrid* grid) {
 598         bool rv = FALSE;
 599         wxPyTState* state = wxPyBeginBlockThreads();
 600         if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
 601             rv = wxPyCBH_callCallback(m_myInst,
 602                 Py_BuildValue("(iiO)", row, col,
 603                               wxPyConstructObject((void*)grid, "wxGrid", 0)));
 604         }
 605         wxPyEndBlockThreads(state);
 606         return rv;
 607     }
 608
 609
 610     wxGridCellEditor*Clone() const {
 611         wxGridCellEditor* rval = NULL;
 612         wxPyTState* state = wxPyBeginBlockThreads();
 613         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 614             PyObject* ro;
 615             wxGridCellEditor* ptr;
 616             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 617             if (ro) {
 618                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
 619                     rval = ptr;
 620                 Py_DECREF(ro);
 621             }
 622         }
 623         wxPyEndBlockThreads(state);
 624         return rval;
 625     }
 626
 627
 628     void Show(bool show, wxGridCellAttr *attr) {
 629         bool found;
 630         wxPyTState* state = wxPyBeginBlockThreads();
 631         if ((found = wxPyCBH_findCallback(m_myInst, "Show")))
 632             wxPyCBH_callCallback(m_myInst,
 633                 Py_BuildValue("(iO)", show,
 634                               wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
 635         wxPyEndBlockThreads(state);
 636         if (! found)
 637             wxGridCellEditor::Show(show, attr);
 638     }
 639     void base_Show(bool show, wxGridCellAttr *attr) {
 640         wxGridCellEditor::Show(show, attr);
 641     }
 642
 643
 644     void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
 645         bool found;                                                             \
 646         wxPyTState* state = wxPyBeginBlockThreads();
 647         if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)")))
 648             wxPyCBH_callCallback(m_myInst,
 649                 Py_BuildValue("(OO)",
 650                               wxPyConstructObject((void*)&rectCell, "wxRect", 0),
 651                               wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
 652         wxPyEndBlockThreads(state);
 653         if (! found)
 654             wxGridCellEditor::PaintBackground(rectCell, attr);
 655     }
 656     void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
 657         wxGridCellEditor::PaintBackground(rectCell, attr);
 658     }
 659
 660
 661     DEC_PYCALLBACK___pure(Reset);
 662     DEC_PYCALLBACK__constany(SetSize, wxRect);
 663     DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
 664     DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
 665     DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
 666     DEC_PYCALLBACK__(StartingClick);
 667     DEC_PYCALLBACK__(Destroy);
 668     DEC_PYCALLBACK__STRING(SetParameters);
 669
 670     PYPRIVATE;
 671 };
 672
 673
 674 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
 675 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
 676 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
 677 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
 678 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
 679 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
 680 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
 681 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
 682
 683
 684 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
 685 {
 686 public:
 687     wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
 688
 689     PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
 690     PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
 691     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
 692     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
 693
 694     PYPRIVATE;
 695 };
 696
 697 class wxPyGridTableBase : public wxGridTableBase
 698 {
 699 public:
 700     wxPyGridTableBase() : wxGridTableBase() {}
 701
 702     PYCALLBACK_INT__pure(GetNumberRows);
 703     PYCALLBACK_INT__pure(GetNumberCols);
 704     PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
 705     PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
 706     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
 707     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
 708     PYCALLBACK__(wxGridTableBase, Clear);
 709     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
 710     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
 711     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
 712     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
 713     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
 714     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
 715     PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
 716     PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
 717     PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
 718     PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
 719     PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
 720     PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
 721     PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
 722     PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
 723     PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
 724
 725
 726     wxString GetValue(int row, int col) {
 727         wxPyTState* state = wxPyBeginBlockThreads();
 728         wxString rval;
 729         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 730             PyObject* ro;
 731             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
 732             if (ro) {
 733                 PyObject* str = PyObject_Str(ro);
 734                 rval = PyString_AsString(str);
 735                 Py_DECREF(ro);
 736                 Py_DECREF(str);
 737             }
 738         }
 739         wxPyEndBlockThreads(state);
 740         return rval;
 741     }
 742
 743     void SetValue(int row, int col, const wxString& val) {
 744         wxPyTState* state = wxPyBeginBlockThreads();
 745         if (wxPyCBH_findCallback(m_myInst, "SetValue"))
 746             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
 747         wxPyEndBlockThreads(state);
 748     }
 749
 750
 751     // Map the Get/Set methods for the standard non-string types to
 752     // the GetValue and SetValue python methods.
 753     long GetValueAsLong( int row, int col ) {
 754         long rval = 0;
 755         wxPyTState* state = wxPyBeginBlockThreads();
 756         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 757             PyObject* ro;
 758             PyObject* num;
 759             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
 760             if (ro && PyNumber_Check(ro)) {
 761                 num = PyNumber_Int(ro);
 762                 if (num) {
 763                     rval = PyInt_AsLong(num);
 764                     Py_DECREF(num);
 765                 }
 766                 Py_DECREF(ro);
 767             }
 768         }
 769         wxPyEndBlockThreads(state);
 770         return rval;
 771     }
 772
 773     double GetValueAsDouble( int row, int col ) {
 774         double rval = 0.0;
 775         wxPyTState* state = wxPyBeginBlockThreads();
 776         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 777             PyObject* ro;
 778             PyObject* num;
 779             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
 780             if (ro && PyNumber_Check(ro)) {
 781                 num = PyNumber_Float(ro);
 782                 if (num) {
 783                     rval = PyFloat_AsDouble(num);
 784                     Py_DECREF(num);
 785                 }
 786                 Py_DECREF(ro);
 787             }
 788         }
 789         wxPyEndBlockThreads(state);
 790         return rval;
 791     }
 792
 793     bool GetValueAsBool( int row, int col ) {
 794         return (bool)GetValueAsLong(row, col);
 795     }
 796
 797     void SetValueAsLong( int row, int col, long value ) {
 798         wxPyTState* state = wxPyBeginBlockThreads();
 799         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
 800             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
 801         }
 802         wxPyEndBlockThreads(state);
 803     }
 804
 805     void SetValueAsDouble( int row, int col, double value ) {
 806         wxPyTState* state = wxPyBeginBlockThreads();
 807         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
 808             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
 809         }
 810         wxPyEndBlockThreads(state);
 811     }
 812
 813     void SetValueAsBool( int row, int col, bool value ) {
 814         SetValueAsLong( row, col, (long)value );
 815     }
 816
 817
 818     PYPRIVATE;
 819 };
 820
 821 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
 822
 823     // If source is an object instance then it may already be the right type
 824     if (PyInstance_Check(source)) {
 825         wxGridCellCoords* ptr;
 826         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxGridCellCoords_p"))
 827             goto error;
 828         *obj = ptr;
 829         return TRUE;
 830     }
 831     // otherwise a 2-tuple of integers is expected
 832     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 833         PyObject* o1 = PySequence_GetItem(source, 0);
 834         PyObject* o2 = PySequence_GetItem(source, 1);
 835         **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
 836         return TRUE;
 837     }
 838
 839  error:
 840     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
 841     return FALSE;
 842 }
 843
 844 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
 845 #ifdef __cplusplus
 846 extern "C" {
 847 #endif
 848 static int _wrap_wxGridNoCellCoords_set(PyObject *val) {
 849
 850     PyErr_SetString(PyExc_TypeError,"Variable wxGridNoCellCoords is read-only.");
 851     return 1;
 852 }
 853
 854 static PyObject *_wrap_wxGridNoCellCoords_get() {
 855     PyObject * pyobj;
 856     char ptemp[128];
 857
 858     SWIG_MakePtr(ptemp,(char *) &wxGridNoCellCoords,"_wxGridCellCoords_p");
 859     pyobj = PyString_FromString(ptemp);
 860     return pyobj;
 861 }
 862
 863 static int _wrap_wxGridNoCellRect_set(PyObject *val) {
 864
 865     PyErr_SetString(PyExc_TypeError,"Variable wxGridNoCellRect is read-only.");
 866     return 1;
 867 }
 868
 869 static PyObject *_wrap_wxGridNoCellRect_get() {
 870     PyObject * pyobj;
 871     char ptemp[128];
 872
 873     SWIG_MakePtr(ptemp,(char *) &wxGridNoCellRect,"_wxRect_p");
 874     pyobj = PyString_FromString(ptemp);
 875     return pyobj;
 876 }
 877
 878 #define wxGridCellRenderer_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
 879 static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
 880     PyObject * _resultobj;
 881     wxGridCellRenderer * _arg0;
 882     wxString * _arg1;
 883     PyObject * _argo0 = 0;
 884     PyObject * _obj1 = 0;
 885     char *_kwnames[] = { "self","params", NULL };
 886
 887     self = self;
 888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellRenderer_SetParameters",_kwnames,&_argo0,&_obj1))
 889         return NULL;
 890     if (_argo0) {
 891         if (_argo0 == Py_None) { _arg0 = NULL; }
 892         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 893             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_SetParameters. Expected _wxGridCellRenderer_p.");
 894         return NULL;
 895         }
 896     }
 897 {
 898 #if PYTHON_API_VERSION >= 1009
 899     char* tmpPtr; int tmpSize;
 900     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 901         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 902         return NULL;
 903     }
 904     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 905         return NULL;
 906     _arg1 = new wxString(tmpPtr, tmpSize);
 907 #else
 908     if (!PyString_Check(_obj1)) {
 909         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 910         return NULL;
 911     }
 912     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 913 #endif
 914 }
 915 {
 916     wxPy_BEGIN_ALLOW_THREADS;
 917         wxGridCellRenderer_SetParameters(_arg0,*_arg1);
 918
 919     wxPy_END_ALLOW_THREADS;
 920     if (PyErr_Occurred()) return NULL;
 921 }    Py_INCREF(Py_None);
 922     _resultobj = Py_None;
 923 {
 924     if (_obj1)
 925         delete _arg1;
 926 }
 927     return _resultobj;
 928 }
 929
 930 #define wxGridCellRenderer_IncRef(_swigobj)  (_swigobj->IncRef())
 931 static PyObject *_wrap_wxGridCellRenderer_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
 932     PyObject * _resultobj;
 933     wxGridCellRenderer * _arg0;
 934     PyObject * _argo0 = 0;
 935     char *_kwnames[] = { "self", NULL };
 936
 937     self = self;
 938     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_IncRef",_kwnames,&_argo0))
 939         return NULL;
 940     if (_argo0) {
 941         if (_argo0 == Py_None) { _arg0 = NULL; }
 942         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 943             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_IncRef. Expected _wxGridCellRenderer_p.");
 944         return NULL;
 945         }
 946     }
 947 {
 948     wxPy_BEGIN_ALLOW_THREADS;
 949         wxGridCellRenderer_IncRef(_arg0);
 950
 951     wxPy_END_ALLOW_THREADS;
 952     if (PyErr_Occurred()) return NULL;
 953 }    Py_INCREF(Py_None);
 954     _resultobj = Py_None;
 955     return _resultobj;
 956 }
 957
 958 #define wxGridCellRenderer_DecRef(_swigobj)  (_swigobj->DecRef())
 959 static PyObject *_wrap_wxGridCellRenderer_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
 960     PyObject * _resultobj;
 961     wxGridCellRenderer * _arg0;
 962     PyObject * _argo0 = 0;
 963     char *_kwnames[] = { "self", NULL };
 964
 965     self = self;
 966     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_DecRef",_kwnames,&_argo0))
 967         return NULL;
 968     if (_argo0) {
 969         if (_argo0 == Py_None) { _arg0 = NULL; }
 970         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 971             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_DecRef. Expected _wxGridCellRenderer_p.");
 972         return NULL;
 973         }
 974     }
 975 {
 976     wxPy_BEGIN_ALLOW_THREADS;
 977         wxGridCellRenderer_DecRef(_arg0);
 978
 979     wxPy_END_ALLOW_THREADS;
 980     if (PyErr_Occurred()) return NULL;
 981 }    Py_INCREF(Py_None);
 982     _resultobj = Py_None;
 983     return _resultobj;
 984 }
 985
 986 #define wxGridCellRenderer_Draw(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6)  (_swigobj->Draw(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
 987 static PyObject *_wrap_wxGridCellRenderer_Draw(PyObject *self, PyObject *args, PyObject *kwargs) {
 988     PyObject * _resultobj;
 989     wxGridCellRenderer * _arg0;
 990     wxGrid * _arg1;
 991     wxGridCellAttr * _arg2;
 992     wxDC * _arg3;
 993     wxRect * _arg4;
 994     int  _arg5;
 995     int  _arg6;
 996     bool  _arg7;
 997     PyObject * _argo0 = 0;
 998     PyObject * _argo1 = 0;
 999     PyObject * _argo2 = 0;
1000     PyObject * _argo3 = 0;
1001     wxRect  temp;
1002     PyObject * _obj4 = 0;
1003     int tempbool7;
1004     char *_kwnames[] = { "self","grid","attr","dc","rect","row","col","isSelected", NULL };
1005
1006     self = self;
1007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOOiii:wxGridCellRenderer_Draw",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_obj4,&_arg5,&_arg6,&tempbool7))
1008         return NULL;
1009     if (_argo0) {
1010         if (_argo0 == Py_None) { _arg0 = NULL; }
1011         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1012             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_Draw. Expected _wxGridCellRenderer_p.");
1013         return NULL;
1014         }
1015     }
1016     if (_argo1) {
1017         if (_argo1 == Py_None) { _arg1 = NULL; }
1018         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
1019             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellRenderer_Draw. Expected _wxGrid_p.");
1020         return NULL;
1021         }
1022     }
1023     if (_argo2) {
1024         if (_argo2 == Py_None) { _arg2 = NULL; }
1025         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
1026             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellRenderer_Draw. Expected _wxGridCellAttr_p.");
1027         return NULL;
1028         }
1029     }
1030     if (_argo3) {
1031         if (_argo3 == Py_None) { _arg3 = NULL; }
1032         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxDC_p")) {
1033             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellRenderer_Draw. Expected _wxDC_p.");
1034         return NULL;
1035         }
1036     }
1037 {
1038     _arg4 = &temp;
1039     if (! wxRect_helper(_obj4, &_arg4))
1040         return NULL;
1041 }
1042     _arg7 = (bool ) tempbool7;
1043 {
1044     wxPy_BEGIN_ALLOW_THREADS;
1045         wxGridCellRenderer_Draw(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7);
1046
1047     wxPy_END_ALLOW_THREADS;
1048     if (PyErr_Occurred()) return NULL;
1049 }    Py_INCREF(Py_None);
1050     _resultobj = Py_None;
1051     return _resultobj;
1052 }
1053
1054 #define wxGridCellRenderer_GetBestSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->GetBestSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1055 static PyObject *_wrap_wxGridCellRenderer_GetBestSize(PyObject *self, PyObject *args, PyObject *kwargs) {
1056     PyObject * _resultobj;
1057     wxSize * _result;
1058     wxGridCellRenderer * _arg0;
1059     wxGrid * _arg1;
1060     wxGridCellAttr * _arg2;
1061     wxDC * _arg3;
1062     int  _arg4;
1063     int  _arg5;
1064     PyObject * _argo0 = 0;
1065     PyObject * _argo1 = 0;
1066     PyObject * _argo2 = 0;
1067     PyObject * _argo3 = 0;
1068     char *_kwnames[] = { "self","grid","attr","dc","row","col", NULL };
1069     char _ptemp[128];
1070
1071     self = self;
1072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOii:wxGridCellRenderer_GetBestSize",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_arg4,&_arg5))
1073         return NULL;
1074     if (_argo0) {
1075         if (_argo0 == Py_None) { _arg0 = NULL; }
1076         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1077             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_GetBestSize. Expected _wxGridCellRenderer_p.");
1078         return NULL;
1079         }
1080     }
1081     if (_argo1) {
1082         if (_argo1 == Py_None) { _arg1 = NULL; }
1083         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
1084             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellRenderer_GetBestSize. Expected _wxGrid_p.");
1085         return NULL;
1086         }
1087     }
1088     if (_argo2) {
1089         if (_argo2 == Py_None) { _arg2 = NULL; }
1090         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
1091             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellRenderer_GetBestSize. Expected _wxGridCellAttr_p.");
1092         return NULL;
1093         }
1094     }
1095     if (_argo3) {
1096         if (_argo3 == Py_None) { _arg3 = NULL; }
1097         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxDC_p")) {
1098             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellRenderer_GetBestSize. Expected _wxDC_p.");
1099         return NULL;
1100         }
1101     }
1102 {
1103     wxPy_BEGIN_ALLOW_THREADS;
1104         _result = new wxSize (wxGridCellRenderer_GetBestSize(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5));
1105
1106     wxPy_END_ALLOW_THREADS;
1107     if (PyErr_Occurred()) return NULL;
1108 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
1109     _resultobj = Py_BuildValue("s",_ptemp);
1110     return _resultobj;
1111 }
1112
1113 #define wxGridCellRenderer_Clone(_swigobj)  (_swigobj->Clone())
1114 static PyObject *_wrap_wxGridCellRenderer_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
1115     PyObject * _resultobj;
1116     wxGridCellRenderer * _result;
1117     wxGridCellRenderer * _arg0;
1118     PyObject * _argo0 = 0;
1119     char *_kwnames[] = { "self", NULL };
1120     char _ptemp[128];
1121
1122     self = self;
1123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_Clone",_kwnames,&_argo0))
1124         return NULL;
1125     if (_argo0) {
1126         if (_argo0 == Py_None) { _arg0 = NULL; }
1127         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1128             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_Clone. Expected _wxGridCellRenderer_p.");
1129         return NULL;
1130         }
1131     }
1132 {
1133     wxPy_BEGIN_ALLOW_THREADS;
1134         _result = (wxGridCellRenderer *)wxGridCellRenderer_Clone(_arg0);
1135
1136     wxPy_END_ALLOW_THREADS;
1137     if (PyErr_Occurred()) return NULL;
1138 }    if (_result) {
1139         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
1140         _resultobj = Py_BuildValue("s",_ptemp);
1141     } else {
1142         Py_INCREF(Py_None);
1143         _resultobj = Py_None;
1144     }
1145     return _resultobj;
1146 }
1147
1148 static void *SwigwxPyGridCellRendererTowxGridCellRenderer(void *ptr) {
1149     wxPyGridCellRenderer *src;
1150     wxGridCellRenderer *dest;
1151     src = (wxPyGridCellRenderer *) ptr;
1152     dest = (wxGridCellRenderer *) src;
1153     return (void *) dest;
1154 }
1155
1156 #define new_wxPyGridCellRenderer() (new wxPyGridCellRenderer())
1157 static PyObject *_wrap_new_wxPyGridCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1158     PyObject * _resultobj;
1159     wxPyGridCellRenderer * _result;
1160     char *_kwnames[] = {  NULL };
1161     char _ptemp[128];
1162
1163     self = self;
1164     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellRenderer",_kwnames))
1165         return NULL;
1166 {
1167     wxPy_BEGIN_ALLOW_THREADS;
1168         _result = (wxPyGridCellRenderer *)new_wxPyGridCellRenderer();
1169
1170     wxPy_END_ALLOW_THREADS;
1171     if (PyErr_Occurred()) return NULL;
1172 }    if (_result) {
1173         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellRenderer_p");
1174         _resultobj = Py_BuildValue("s",_ptemp);
1175     } else {
1176         Py_INCREF(Py_None);
1177         _resultobj = Py_None;
1178     }
1179     return _resultobj;
1180 }
1181
1182 #define wxPyGridCellRenderer__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
1183 static PyObject *_wrap_wxPyGridCellRenderer__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
1184     PyObject * _resultobj;
1185     wxPyGridCellRenderer * _arg0;
1186     PyObject * _arg1;
1187     PyObject * _arg2;
1188     PyObject * _argo0 = 0;
1189     PyObject * _obj1 = 0;
1190     PyObject * _obj2 = 0;
1191     char *_kwnames[] = { "self","self","_class", NULL };
1192
1193     self = self;
1194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellRenderer__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
1195         return NULL;
1196     if (_argo0) {
1197         if (_argo0 == Py_None) { _arg0 = NULL; }
1198         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
1199             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer__setCallbackInfo. Expected _wxPyGridCellRenderer_p.");
1200         return NULL;
1201         }
1202     }
1203 {
1204   _arg1 = _obj1;
1205 }
1206 {
1207   _arg2 = _obj2;
1208 }
1209 {
1210     wxPy_BEGIN_ALLOW_THREADS;
1211         wxPyGridCellRenderer__setCallbackInfo(_arg0,_arg1,_arg2);
1212
1213     wxPy_END_ALLOW_THREADS;
1214     if (PyErr_Occurred()) return NULL;
1215 }    Py_INCREF(Py_None);
1216     _resultobj = Py_None;
1217     return _resultobj;
1218 }
1219
1220 #define wxPyGridCellRenderer_base_SetParameters(_swigobj,_swigarg0)  (_swigobj->base_SetParameters(_swigarg0))
1221 static PyObject *_wrap_wxPyGridCellRenderer_base_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
1222     PyObject * _resultobj;
1223     wxPyGridCellRenderer * _arg0;
1224     wxString * _arg1;
1225     PyObject * _argo0 = 0;
1226     PyObject * _obj1 = 0;
1227     char *_kwnames[] = { "self","params", NULL };
1228
1229     self = self;
1230     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellRenderer_base_SetParameters",_kwnames,&_argo0,&_obj1))
1231         return NULL;
1232     if (_argo0) {
1233         if (_argo0 == Py_None) { _arg0 = NULL; }
1234         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
1235             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer_base_SetParameters. Expected _wxPyGridCellRenderer_p.");
1236         return NULL;
1237         }
1238     }
1239 {
1240 #if PYTHON_API_VERSION >= 1009
1241     char* tmpPtr; int tmpSize;
1242     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1243         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1244         return NULL;
1245     }
1246     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1247         return NULL;
1248     _arg1 = new wxString(tmpPtr, tmpSize);
1249 #else
1250     if (!PyString_Check(_obj1)) {
1251         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1252         return NULL;
1253     }
1254     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1255 #endif
1256 }
1257 {
1258     wxPy_BEGIN_ALLOW_THREADS;
1259         wxPyGridCellRenderer_base_SetParameters(_arg0,*_arg1);
1260
1261     wxPy_END_ALLOW_THREADS;
1262     if (PyErr_Occurred()) return NULL;
1263 }    Py_INCREF(Py_None);
1264     _resultobj = Py_None;
1265 {
1266     if (_obj1)
1267         delete _arg1;
1268 }
1269     return _resultobj;
1270 }
1271
1272 static void *SwigwxGridCellStringRendererTowxGridCellRenderer(void *ptr) {
1273     wxGridCellStringRenderer *src;
1274     wxGridCellRenderer *dest;
1275     src = (wxGridCellStringRenderer *) ptr;
1276     dest = (wxGridCellRenderer *) src;
1277     return (void *) dest;
1278 }
1279
1280 #define new_wxGridCellStringRenderer() (new wxGridCellStringRenderer())
1281 static PyObject *_wrap_new_wxGridCellStringRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1282     PyObject * _resultobj;
1283     wxGridCellStringRenderer * _result;
1284     char *_kwnames[] = {  NULL };
1285     char _ptemp[128];
1286
1287     self = self;
1288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellStringRenderer",_kwnames))
1289         return NULL;
1290 {
1291     wxPy_BEGIN_ALLOW_THREADS;
1292         _result = (wxGridCellStringRenderer *)new_wxGridCellStringRenderer();
1293
1294     wxPy_END_ALLOW_THREADS;
1295     if (PyErr_Occurred()) return NULL;
1296 }    if (_result) {
1297         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellStringRenderer_p");
1298         _resultobj = Py_BuildValue("s",_ptemp);
1299     } else {
1300         Py_INCREF(Py_None);
1301         _resultobj = Py_None;
1302     }
1303     return _resultobj;
1304 }
1305
1306 static void *SwigwxGridCellNumberRendererTowxGridCellStringRenderer(void *ptr) {
1307     wxGridCellNumberRenderer *src;
1308     wxGridCellStringRenderer *dest;
1309     src = (wxGridCellNumberRenderer *) ptr;
1310     dest = (wxGridCellStringRenderer *) src;
1311     return (void *) dest;
1312 }
1313
1314 static void *SwigwxGridCellNumberRendererTowxGridCellRenderer(void *ptr) {
1315     wxGridCellNumberRenderer *src;
1316     wxGridCellRenderer *dest;
1317     src = (wxGridCellNumberRenderer *) ptr;
1318     dest = (wxGridCellRenderer *) src;
1319     return (void *) dest;
1320 }
1321
1322 #define new_wxGridCellNumberRenderer() (new wxGridCellNumberRenderer())
1323 static PyObject *_wrap_new_wxGridCellNumberRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1324     PyObject * _resultobj;
1325     wxGridCellNumberRenderer * _result;
1326     char *_kwnames[] = {  NULL };
1327     char _ptemp[128];
1328
1329     self = self;
1330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellNumberRenderer",_kwnames))
1331         return NULL;
1332 {
1333     wxPy_BEGIN_ALLOW_THREADS;
1334         _result = (wxGridCellNumberRenderer *)new_wxGridCellNumberRenderer();
1335
1336     wxPy_END_ALLOW_THREADS;
1337     if (PyErr_Occurred()) return NULL;
1338 }    if (_result) {
1339         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberRenderer_p");
1340         _resultobj = Py_BuildValue("s",_ptemp);
1341     } else {
1342         Py_INCREF(Py_None);
1343         _resultobj = Py_None;
1344     }
1345     return _resultobj;
1346 }
1347
1348 static void *SwigwxGridCellFloatRendererTowxGridCellStringRenderer(void *ptr) {
1349     wxGridCellFloatRenderer *src;
1350     wxGridCellStringRenderer *dest;
1351     src = (wxGridCellFloatRenderer *) ptr;
1352     dest = (wxGridCellStringRenderer *) src;
1353     return (void *) dest;
1354 }
1355
1356 static void *SwigwxGridCellFloatRendererTowxGridCellRenderer(void *ptr) {
1357     wxGridCellFloatRenderer *src;
1358     wxGridCellRenderer *dest;
1359     src = (wxGridCellFloatRenderer *) ptr;
1360     dest = (wxGridCellRenderer *) src;
1361     return (void *) dest;
1362 }
1363
1364 #define new_wxGridCellFloatRenderer(_swigarg0,_swigarg1) (new wxGridCellFloatRenderer(_swigarg0,_swigarg1))
1365 static PyObject *_wrap_new_wxGridCellFloatRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1366     PyObject * _resultobj;
1367     wxGridCellFloatRenderer * _result;
1368     int  _arg0 = (int ) -1;
1369     int  _arg1 = (int ) -1;
1370     char *_kwnames[] = { "width","precision", NULL };
1371     char _ptemp[128];
1372
1373     self = self;
1374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellFloatRenderer",_kwnames,&_arg0,&_arg1))
1375         return NULL;
1376 {
1377     wxPy_BEGIN_ALLOW_THREADS;
1378         _result = (wxGridCellFloatRenderer *)new_wxGridCellFloatRenderer(_arg0,_arg1);
1379
1380     wxPy_END_ALLOW_THREADS;
1381     if (PyErr_Occurred()) return NULL;
1382 }    if (_result) {
1383         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatRenderer_p");
1384         _resultobj = Py_BuildValue("s",_ptemp);
1385     } else {
1386         Py_INCREF(Py_None);
1387         _resultobj = Py_None;
1388     }
1389     return _resultobj;
1390 }
1391
1392 #define wxGridCellFloatRenderer_GetWidth(_swigobj)  (_swigobj->GetWidth())
1393 static PyObject *_wrap_wxGridCellFloatRenderer_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1394     PyObject * _resultobj;
1395     int  _result;
1396     wxGridCellFloatRenderer * _arg0;
1397     PyObject * _argo0 = 0;
1398     char *_kwnames[] = { "self", NULL };
1399
1400     self = self;
1401     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellFloatRenderer_GetWidth",_kwnames,&_argo0))
1402         return NULL;
1403     if (_argo0) {
1404         if (_argo0 == Py_None) { _arg0 = NULL; }
1405         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1406             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_GetWidth. Expected _wxGridCellFloatRenderer_p.");
1407         return NULL;
1408         }
1409     }
1410 {
1411     wxPy_BEGIN_ALLOW_THREADS;
1412         _result = (int )wxGridCellFloatRenderer_GetWidth(_arg0);
1413
1414     wxPy_END_ALLOW_THREADS;
1415     if (PyErr_Occurred()) return NULL;
1416 }    _resultobj = Py_BuildValue("i",_result);
1417     return _resultobj;
1418 }
1419
1420 #define wxGridCellFloatRenderer_SetWidth(_swigobj,_swigarg0)  (_swigobj->SetWidth(_swigarg0))
1421 static PyObject *_wrap_wxGridCellFloatRenderer_SetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1422     PyObject * _resultobj;
1423     wxGridCellFloatRenderer * _arg0;
1424     int  _arg1;
1425     PyObject * _argo0 = 0;
1426     char *_kwnames[] = { "self","width", NULL };
1427
1428     self = self;
1429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellFloatRenderer_SetWidth",_kwnames,&_argo0,&_arg1))
1430         return NULL;
1431     if (_argo0) {
1432         if (_argo0 == Py_None) { _arg0 = NULL; }
1433         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1434             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_SetWidth. Expected _wxGridCellFloatRenderer_p.");
1435         return NULL;
1436         }
1437     }
1438 {
1439     wxPy_BEGIN_ALLOW_THREADS;
1440         wxGridCellFloatRenderer_SetWidth(_arg0,_arg1);
1441
1442     wxPy_END_ALLOW_THREADS;
1443     if (PyErr_Occurred()) return NULL;
1444 }    Py_INCREF(Py_None);
1445     _resultobj = Py_None;
1446     return _resultobj;
1447 }
1448
1449 #define wxGridCellFloatRenderer_GetPrecision(_swigobj)  (_swigobj->GetPrecision())
1450 static PyObject *_wrap_wxGridCellFloatRenderer_GetPrecision(PyObject *self, PyObject *args, PyObject *kwargs) {
1451     PyObject * _resultobj;
1452     int  _result;
1453     wxGridCellFloatRenderer * _arg0;
1454     PyObject * _argo0 = 0;
1455     char *_kwnames[] = { "self", NULL };
1456
1457     self = self;
1458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellFloatRenderer_GetPrecision",_kwnames,&_argo0))
1459         return NULL;
1460     if (_argo0) {
1461         if (_argo0 == Py_None) { _arg0 = NULL; }
1462         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1463             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_GetPrecision. Expected _wxGridCellFloatRenderer_p.");
1464         return NULL;
1465         }
1466     }
1467 {
1468     wxPy_BEGIN_ALLOW_THREADS;
1469         _result = (int )wxGridCellFloatRenderer_GetPrecision(_arg0);
1470
1471     wxPy_END_ALLOW_THREADS;
1472     if (PyErr_Occurred()) return NULL;
1473 }    _resultobj = Py_BuildValue("i",_result);
1474     return _resultobj;
1475 }
1476
1477 #define wxGridCellFloatRenderer_SetPrecision(_swigobj,_swigarg0)  (_swigobj->SetPrecision(_swigarg0))
1478 static PyObject *_wrap_wxGridCellFloatRenderer_SetPrecision(PyObject *self, PyObject *args, PyObject *kwargs) {
1479     PyObject * _resultobj;
1480     wxGridCellFloatRenderer * _arg0;
1481     int  _arg1;
1482     PyObject * _argo0 = 0;
1483     char *_kwnames[] = { "self","precision", NULL };
1484
1485     self = self;
1486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellFloatRenderer_SetPrecision",_kwnames,&_argo0,&_arg1))
1487         return NULL;
1488     if (_argo0) {
1489         if (_argo0 == Py_None) { _arg0 = NULL; }
1490         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1491             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_SetPrecision. Expected _wxGridCellFloatRenderer_p.");
1492         return NULL;
1493         }
1494     }
1495 {
1496     wxPy_BEGIN_ALLOW_THREADS;
1497         wxGridCellFloatRenderer_SetPrecision(_arg0,_arg1);
1498
1499     wxPy_END_ALLOW_THREADS;
1500     if (PyErr_Occurred()) return NULL;
1501 }    Py_INCREF(Py_None);
1502     _resultobj = Py_None;
1503     return _resultobj;
1504 }
1505
1506 static void *SwigwxGridCellBoolRendererTowxGridCellRenderer(void *ptr) {
1507     wxGridCellBoolRenderer *src;
1508     wxGridCellRenderer *dest;
1509     src = (wxGridCellBoolRenderer *) ptr;
1510     dest = (wxGridCellRenderer *) src;
1511     return (void *) dest;
1512 }
1513
1514 #define new_wxGridCellBoolRenderer() (new wxGridCellBoolRenderer())
1515 static PyObject *_wrap_new_wxGridCellBoolRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1516     PyObject * _resultobj;
1517     wxGridCellBoolRenderer * _result;
1518     char *_kwnames[] = {  NULL };
1519     char _ptemp[128];
1520
1521     self = self;
1522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolRenderer",_kwnames))
1523         return NULL;
1524 {
1525     wxPy_BEGIN_ALLOW_THREADS;
1526         _result = (wxGridCellBoolRenderer *)new_wxGridCellBoolRenderer();
1527
1528     wxPy_END_ALLOW_THREADS;
1529     if (PyErr_Occurred()) return NULL;
1530 }    if (_result) {
1531         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolRenderer_p");
1532         _resultobj = Py_BuildValue("s",_ptemp);
1533     } else {
1534         Py_INCREF(Py_None);
1535         _resultobj = Py_None;
1536     }
1537     return _resultobj;
1538 }
1539
1540 static void *SwigwxGridCellDateTimeRendererTowxGridCellStringRenderer(void *ptr) {
1541     wxGridCellDateTimeRenderer *src;
1542     wxGridCellStringRenderer *dest;
1543     src = (wxGridCellDateTimeRenderer *) ptr;
1544     dest = (wxGridCellStringRenderer *) src;
1545     return (void *) dest;
1546 }
1547
1548 static void *SwigwxGridCellDateTimeRendererTowxGridCellRenderer(void *ptr) {
1549     wxGridCellDateTimeRenderer *src;
1550     wxGridCellRenderer *dest;
1551     src = (wxGridCellDateTimeRenderer *) ptr;
1552     dest = (wxGridCellRenderer *) src;
1553     return (void *) dest;
1554 }
1555
1556 #define new_wxGridCellDateTimeRenderer(_swigarg0,_swigarg1) (new wxGridCellDateTimeRenderer(_swigarg0,_swigarg1))
1557 static PyObject *_wrap_new_wxGridCellDateTimeRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1558     PyObject * _resultobj;
1559     wxGridCellDateTimeRenderer * _result;
1560     wxString * _arg0 = (wxString *) &"%c";
1561     wxString * _arg1 = (wxString *) &"%c";
1562     PyObject * _obj0 = 0;
1563     PyObject * _obj1 = 0;
1564     char *_kwnames[] = { "outformat","informat", NULL };
1565     char _ptemp[128];
1566
1567     self = self;
1568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|OO:new_wxGridCellDateTimeRenderer",_kwnames,&_obj0,&_obj1))
1569         return NULL;
1570     if (_obj0)
1571 {
1572 #if PYTHON_API_VERSION >= 1009
1573     char* tmpPtr; int tmpSize;
1574     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1575         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1576         return NULL;
1577     }
1578     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1579         return NULL;
1580     _arg0 = new wxString(tmpPtr, tmpSize);
1581 #else
1582     if (!PyString_Check(_obj0)) {
1583         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1584         return NULL;
1585     }
1586     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1587 #endif
1588 }
1589     if (_obj1)
1590 {
1591 #if PYTHON_API_VERSION >= 1009
1592     char* tmpPtr; int tmpSize;
1593     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1594         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1595         return NULL;
1596     }
1597     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1598         return NULL;
1599     _arg1 = new wxString(tmpPtr, tmpSize);
1600 #else
1601     if (!PyString_Check(_obj1)) {
1602         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1603         return NULL;
1604     }
1605     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1606 #endif
1607 }
1608 {
1609     wxPy_BEGIN_ALLOW_THREADS;
1610         _result = (wxGridCellDateTimeRenderer *)new_wxGridCellDateTimeRenderer(*_arg0,*_arg1);
1611
1612     wxPy_END_ALLOW_THREADS;
1613     if (PyErr_Occurred()) return NULL;
1614 }    if (_result) {
1615         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellDateTimeRenderer_p");
1616         _resultobj = Py_BuildValue("s",_ptemp);
1617     } else {
1618         Py_INCREF(Py_None);
1619         _resultobj = Py_None;
1620     }
1621 {
1622     if (_obj0)
1623         delete _arg0;
1624 }
1625 {
1626     if (_obj1)
1627         delete _arg1;
1628 }
1629     return _resultobj;
1630 }
1631
1632 static void *SwigwxGridCellEnumRendererTowxGridCellStringRenderer(void *ptr) {
1633     wxGridCellEnumRenderer *src;
1634     wxGridCellStringRenderer *dest;
1635     src = (wxGridCellEnumRenderer *) ptr;
1636     dest = (wxGridCellStringRenderer *) src;
1637     return (void *) dest;
1638 }
1639
1640 static void *SwigwxGridCellEnumRendererTowxGridCellRenderer(void *ptr) {
1641     wxGridCellEnumRenderer *src;
1642     wxGridCellRenderer *dest;
1643     src = (wxGridCellEnumRenderer *) ptr;
1644     dest = (wxGridCellRenderer *) src;
1645     return (void *) dest;
1646 }
1647
1648 #define new_wxGridCellEnumRenderer(_swigarg0) (new wxGridCellEnumRenderer(_swigarg0))
1649 static PyObject *_wrap_new_wxGridCellEnumRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1650     PyObject * _resultobj;
1651     wxGridCellEnumRenderer * _result;
1652     wxString * _arg0 = (wxString *) &"";
1653     PyObject * _obj0 = 0;
1654     char *_kwnames[] = { "choices", NULL };
1655     char _ptemp[128];
1656
1657     self = self;
1658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxGridCellEnumRenderer",_kwnames,&_obj0))
1659         return NULL;
1660     if (_obj0)
1661 {
1662     _arg0 = wxString_LIST_helper(_obj0);
1663     if (_arg0 == NULL) {
1664         return NULL;
1665     }
1666 }
1667 {
1668     wxPy_BEGIN_ALLOW_THREADS;
1669         _result = (wxGridCellEnumRenderer *)new_wxGridCellEnumRenderer(*_arg0);
1670
1671     wxPy_END_ALLOW_THREADS;
1672     if (PyErr_Occurred()) return NULL;
1673 }    if (_result) {
1674         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumRenderer_p");
1675         _resultobj = Py_BuildValue("s",_ptemp);
1676     } else {
1677         Py_INCREF(Py_None);
1678         _resultobj = Py_None;
1679     }
1680 {
1681     delete [] _arg0;
1682 }
1683     return _resultobj;
1684 }
1685
1686 static void *SwigwxGridCellAutoWrapStringRendererTowxGridCellStringRenderer(void *ptr) {
1687     wxGridCellAutoWrapStringRenderer *src;
1688     wxGridCellStringRenderer *dest;
1689     src = (wxGridCellAutoWrapStringRenderer *) ptr;
1690     dest = (wxGridCellStringRenderer *) src;
1691     return (void *) dest;
1692 }
1693
1694 static void *SwigwxGridCellAutoWrapStringRendererTowxGridCellRenderer(void *ptr) {
1695     wxGridCellAutoWrapStringRenderer *src;
1696     wxGridCellRenderer *dest;
1697     src = (wxGridCellAutoWrapStringRenderer *) ptr;
1698     dest = (wxGridCellRenderer *) src;
1699     return (void *) dest;
1700 }
1701
1702 #define new_wxGridCellAutoWrapStringRenderer() (new wxGridCellAutoWrapStringRenderer())
1703 static PyObject *_wrap_new_wxGridCellAutoWrapStringRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1704     PyObject * _resultobj;
1705     wxGridCellAutoWrapStringRenderer * _result;
1706     char *_kwnames[] = {  NULL };
1707     char _ptemp[128];
1708
1709     self = self;
1710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringRenderer",_kwnames))
1711         return NULL;
1712 {
1713     wxPy_BEGIN_ALLOW_THREADS;
1714         _result = (wxGridCellAutoWrapStringRenderer *)new_wxGridCellAutoWrapStringRenderer();
1715
1716     wxPy_END_ALLOW_THREADS;
1717     if (PyErr_Occurred()) return NULL;
1718 }    if (_result) {
1719         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringRenderer_p");
1720         _resultobj = Py_BuildValue("s",_ptemp);
1721     } else {
1722         Py_INCREF(Py_None);
1723         _resultobj = Py_None;
1724     }
1725     return _resultobj;
1726 }
1727
1728 #define wxGridCellEditor_IsCreated(_swigobj)  (_swigobj->IsCreated())
1729 static PyObject *_wrap_wxGridCellEditor_IsCreated(PyObject *self, PyObject *args, PyObject *kwargs) {
1730     PyObject * _resultobj;
1731     bool  _result;
1732     wxGridCellEditor * _arg0;
1733     PyObject * _argo0 = 0;
1734     char *_kwnames[] = { "self", NULL };
1735
1736     self = self;
1737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_IsCreated",_kwnames,&_argo0))
1738         return NULL;
1739     if (_argo0) {
1740         if (_argo0 == Py_None) { _arg0 = NULL; }
1741         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1742             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IsCreated. Expected _wxGridCellEditor_p.");
1743         return NULL;
1744         }
1745     }
1746 {
1747     wxPy_BEGIN_ALLOW_THREADS;
1748         _result = (bool )wxGridCellEditor_IsCreated(_arg0);
1749
1750     wxPy_END_ALLOW_THREADS;
1751     if (PyErr_Occurred()) return NULL;
1752 }    _resultobj = Py_BuildValue("i",_result);
1753     return _resultobj;
1754 }
1755
1756 #define wxGridCellEditor_GetControl(_swigobj)  (_swigobj->GetControl())
1757 static PyObject *_wrap_wxGridCellEditor_GetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
1758     PyObject * _resultobj;
1759     wxControl * _result;
1760     wxGridCellEditor * _arg0;
1761     PyObject * _argo0 = 0;
1762     char *_kwnames[] = { "self", NULL };
1763
1764     self = self;
1765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_GetControl",_kwnames,&_argo0))
1766         return NULL;
1767     if (_argo0) {
1768         if (_argo0 == Py_None) { _arg0 = NULL; }
1769         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1770             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_GetControl. Expected _wxGridCellEditor_p.");
1771         return NULL;
1772         }
1773     }
1774 {
1775     wxPy_BEGIN_ALLOW_THREADS;
1776         _result = (wxControl *)wxGridCellEditor_GetControl(_arg0);
1777
1778     wxPy_END_ALLOW_THREADS;
1779     if (PyErr_Occurred()) return NULL;
1780 }{ _resultobj = wxPyMake_wxObject(_result); }
1781     return _resultobj;
1782 }
1783
1784 #define wxGridCellEditor_SetControl(_swigobj,_swigarg0)  (_swigobj->SetControl(_swigarg0))
1785 static PyObject *_wrap_wxGridCellEditor_SetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
1786     PyObject * _resultobj;
1787     wxGridCellEditor * _arg0;
1788     wxControl * _arg1;
1789     PyObject * _argo0 = 0;
1790     PyObject * _argo1 = 0;
1791     char *_kwnames[] = { "self","control", NULL };
1792
1793     self = self;
1794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetControl",_kwnames,&_argo0,&_argo1))
1795         return NULL;
1796     if (_argo0) {
1797         if (_argo0 == Py_None) { _arg0 = NULL; }
1798         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1799             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetControl. Expected _wxGridCellEditor_p.");
1800         return NULL;
1801         }
1802     }
1803     if (_argo1) {
1804         if (_argo1 == Py_None) { _arg1 = NULL; }
1805         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxControl_p")) {
1806             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_SetControl. Expected _wxControl_p.");
1807         return NULL;
1808         }
1809     }
1810 {
1811     wxPy_BEGIN_ALLOW_THREADS;
1812         wxGridCellEditor_SetControl(_arg0,_arg1);
1813
1814     wxPy_END_ALLOW_THREADS;
1815     if (PyErr_Occurred()) return NULL;
1816 }    Py_INCREF(Py_None);
1817     _resultobj = Py_None;
1818     return _resultobj;
1819 }
1820
1821 #define wxGridCellEditor_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
1822 static PyObject *_wrap_wxGridCellEditor_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
1823     PyObject * _resultobj;
1824     wxGridCellEditor * _arg0;
1825     wxString * _arg1;
1826     PyObject * _argo0 = 0;
1827     PyObject * _obj1 = 0;
1828     char *_kwnames[] = { "self","params", NULL };
1829
1830     self = self;
1831     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetParameters",_kwnames,&_argo0,&_obj1))
1832         return NULL;
1833     if (_argo0) {
1834         if (_argo0 == Py_None) { _arg0 = NULL; }
1835         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1836             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetParameters. Expected _wxGridCellEditor_p.");
1837         return NULL;
1838         }
1839     }
1840 {
1841 #if PYTHON_API_VERSION >= 1009
1842     char* tmpPtr; int tmpSize;
1843     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1844         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1845         return NULL;
1846     }
1847     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1848         return NULL;
1849     _arg1 = new wxString(tmpPtr, tmpSize);
1850 #else
1851     if (!PyString_Check(_obj1)) {
1852         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1853         return NULL;
1854     }
1855     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1856 #endif
1857 }
1858 {
1859     wxPy_BEGIN_ALLOW_THREADS;
1860         wxGridCellEditor_SetParameters(_arg0,*_arg1);
1861
1862     wxPy_END_ALLOW_THREADS;
1863     if (PyErr_Occurred()) return NULL;
1864 }    Py_INCREF(Py_None);
1865     _resultobj = Py_None;
1866 {
1867     if (_obj1)
1868         delete _arg1;
1869 }
1870     return _resultobj;
1871 }
1872
1873 #define wxGridCellEditor_IncRef(_swigobj)  (_swigobj->IncRef())
1874 static PyObject *_wrap_wxGridCellEditor_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
1875     PyObject * _resultobj;
1876     wxGridCellEditor * _arg0;
1877     PyObject * _argo0 = 0;
1878     char *_kwnames[] = { "self", NULL };
1879
1880     self = self;
1881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_IncRef",_kwnames,&_argo0))
1882         return NULL;
1883     if (_argo0) {
1884         if (_argo0 == Py_None) { _arg0 = NULL; }
1885         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1886             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IncRef. Expected _wxGridCellEditor_p.");
1887         return NULL;
1888         }
1889     }
1890 {
1891     wxPy_BEGIN_ALLOW_THREADS;
1892         wxGridCellEditor_IncRef(_arg0);
1893
1894     wxPy_END_ALLOW_THREADS;
1895     if (PyErr_Occurred()) return NULL;
1896 }    Py_INCREF(Py_None);
1897     _resultobj = Py_None;
1898     return _resultobj;
1899 }
1900
1901 #define wxGridCellEditor_DecRef(_swigobj)  (_swigobj->DecRef())
1902 static PyObject *_wrap_wxGridCellEditor_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
1903     PyObject * _resultobj;
1904     wxGridCellEditor * _arg0;
1905     PyObject * _argo0 = 0;
1906     char *_kwnames[] = { "self", NULL };
1907
1908     self = self;
1909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_DecRef",_kwnames,&_argo0))
1910         return NULL;
1911     if (_argo0) {
1912         if (_argo0 == Py_None) { _arg0 = NULL; }
1913         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1914             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_DecRef. Expected _wxGridCellEditor_p.");
1915         return NULL;
1916         }
1917     }
1918 {
1919     wxPy_BEGIN_ALLOW_THREADS;
1920         wxGridCellEditor_DecRef(_arg0);
1921
1922     wxPy_END_ALLOW_THREADS;
1923     if (PyErr_Occurred()) return NULL;
1924 }    Py_INCREF(Py_None);
1925     _resultobj = Py_None;
1926     return _resultobj;
1927 }
1928
1929 #define wxGridCellEditor_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2))
1930 static PyObject *_wrap_wxGridCellEditor_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1931     PyObject * _resultobj;
1932     wxGridCellEditor * _arg0;
1933     wxWindow * _arg1;
1934     wxWindowID  _arg2;
1935     wxEvtHandler * _arg3;
1936     PyObject * _argo0 = 0;
1937     PyObject * _argo1 = 0;
1938     PyObject * _argo3 = 0;
1939     char *_kwnames[] = { "self","parent","id","evtHandler", NULL };
1940
1941     self = self;
1942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOiO:wxGridCellEditor_Create",_kwnames,&_argo0,&_argo1,&_arg2,&_argo3))
1943         return NULL;
1944     if (_argo0) {
1945         if (_argo0 == Py_None) { _arg0 = NULL; }
1946         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1947             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Create. Expected _wxGridCellEditor_p.");
1948         return NULL;
1949         }
1950     }
1951     if (_argo1) {
1952         if (_argo1 == Py_None) { _arg1 = NULL; }
1953         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
1954             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_Create. Expected _wxWindow_p.");
1955         return NULL;
1956         }
1957     }
1958     if (_argo3) {
1959         if (_argo3 == Py_None) { _arg3 = NULL; }
1960         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxEvtHandler_p")) {
1961             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_Create. Expected _wxEvtHandler_p.");
1962         return NULL;
1963         }
1964     }
1965 {
1966     wxPy_BEGIN_ALLOW_THREADS;
1967         wxGridCellEditor_Create(_arg0,_arg1,_arg2,_arg3);
1968
1969     wxPy_END_ALLOW_THREADS;
1970     if (PyErr_Occurred()) return NULL;
1971 }    Py_INCREF(Py_None);
1972     _resultobj = Py_None;
1973     return _resultobj;
1974 }
1975
1976 #define wxGridCellEditor_BeginEdit(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->BeginEdit(_swigarg0,_swigarg1,_swigarg2))
1977 static PyObject *_wrap_wxGridCellEditor_BeginEdit(PyObject *self, PyObject *args, PyObject *kwargs) {
1978     PyObject * _resultobj;
1979     wxGridCellEditor * _arg0;
1980     int  _arg1;
1981     int  _arg2;
1982     wxGrid * _arg3;
1983     PyObject * _argo0 = 0;
1984     PyObject * _argo3 = 0;
1985     char *_kwnames[] = { "self","row","col","grid", NULL };
1986
1987     self = self;
1988     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridCellEditor_BeginEdit",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
1989         return NULL;
1990     if (_argo0) {
1991         if (_argo0 == Py_None) { _arg0 = NULL; }
1992         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1993             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_BeginEdit. Expected _wxGridCellEditor_p.");
1994         return NULL;
1995         }
1996     }
1997     if (_argo3) {
1998         if (_argo3 == Py_None) { _arg3 = NULL; }
1999         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGrid_p")) {
2000             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_BeginEdit. Expected _wxGrid_p.");
2001         return NULL;
2002         }
2003     }
2004 {
2005     wxPy_BEGIN_ALLOW_THREADS;
2006         wxGridCellEditor_BeginEdit(_arg0,_arg1,_arg2,_arg3);
2007
2008     wxPy_END_ALLOW_THREADS;
2009     if (PyErr_Occurred()) return NULL;
2010 }    Py_INCREF(Py_None);
2011     _resultobj = Py_None;
2012     return _resultobj;
2013 }
2014
2015 #define wxGridCellEditor_EndEdit(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->EndEdit(_swigarg0,_swigarg1,_swigarg2))
2016 static PyObject *_wrap_wxGridCellEditor_EndEdit(PyObject *self, PyObject *args, PyObject *kwargs) {
2017     PyObject * _resultobj;
2018     bool  _result;
2019     wxGridCellEditor * _arg0;
2020     int  _arg1;
2021     int  _arg2;
2022     wxGrid * _arg3;
2023     PyObject * _argo0 = 0;
2024     PyObject * _argo3 = 0;
2025     char *_kwnames[] = { "self","row","col","grid", NULL };
2026
2027     self = self;
2028     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridCellEditor_EndEdit",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
2029         return NULL;
2030     if (_argo0) {
2031         if (_argo0 == Py_None) { _arg0 = NULL; }
2032         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2033             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_EndEdit. Expected _wxGridCellEditor_p.");
2034         return NULL;
2035         }
2036     }
2037     if (_argo3) {
2038         if (_argo3 == Py_None) { _arg3 = NULL; }
2039         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGrid_p")) {
2040             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_EndEdit. Expected _wxGrid_p.");
2041         return NULL;
2042         }
2043     }
2044 {
2045     wxPy_BEGIN_ALLOW_THREADS;
2046         _result = (bool )wxGridCellEditor_EndEdit(_arg0,_arg1,_arg2,_arg3);
2047
2048     wxPy_END_ALLOW_THREADS;
2049     if (PyErr_Occurred()) return NULL;
2050 }    _resultobj = Py_BuildValue("i",_result);
2051     return _resultobj;
2052 }
2053
2054 #define wxGridCellEditor_Reset(_swigobj)  (_swigobj->Reset())
2055 static PyObject *_wrap_wxGridCellEditor_Reset(PyObject *self, PyObject *args, PyObject *kwargs) {
2056     PyObject * _resultobj;
2057     wxGridCellEditor * _arg0;
2058     PyObject * _argo0 = 0;
2059     char *_kwnames[] = { "self", NULL };
2060
2061     self = self;
2062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Reset",_kwnames,&_argo0))
2063         return NULL;
2064     if (_argo0) {
2065         if (_argo0 == Py_None) { _arg0 = NULL; }
2066         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2067             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Reset. Expected _wxGridCellEditor_p.");
2068         return NULL;
2069         }
2070     }
2071 {
2072     wxPy_BEGIN_ALLOW_THREADS;
2073         wxGridCellEditor_Reset(_arg0);
2074
2075     wxPy_END_ALLOW_THREADS;
2076     if (PyErr_Occurred()) return NULL;
2077 }    Py_INCREF(Py_None);
2078     _resultobj = Py_None;
2079     return _resultobj;
2080 }
2081
2082 #define wxGridCellEditor_Clone(_swigobj)  (_swigobj->Clone())
2083 static PyObject *_wrap_wxGridCellEditor_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
2084     PyObject * _resultobj;
2085     wxGridCellEditor * _result;
2086     wxGridCellEditor * _arg0;
2087     PyObject * _argo0 = 0;
2088     char *_kwnames[] = { "self", NULL };
2089     char _ptemp[128];
2090
2091     self = self;
2092     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Clone",_kwnames,&_argo0))
2093         return NULL;
2094     if (_argo0) {
2095         if (_argo0 == Py_None) { _arg0 = NULL; }
2096         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2097             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Clone. Expected _wxGridCellEditor_p.");
2098         return NULL;
2099         }
2100     }
2101 {
2102     wxPy_BEGIN_ALLOW_THREADS;
2103         _result = (wxGridCellEditor *)wxGridCellEditor_Clone(_arg0);
2104
2105     wxPy_END_ALLOW_THREADS;
2106     if (PyErr_Occurred()) return NULL;
2107 }    if (_result) {
2108         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
2109         _resultobj = Py_BuildValue("s",_ptemp);
2110     } else {
2111         Py_INCREF(Py_None);
2112         _resultobj = Py_None;
2113     }
2114     return _resultobj;
2115 }
2116
2117 #define wxGridCellEditor_SetSize(_swigobj,_swigarg0)  (_swigobj->SetSize(_swigarg0))
2118 static PyObject *_wrap_wxGridCellEditor_SetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
2119     PyObject * _resultobj;
2120     wxGridCellEditor * _arg0;
2121     wxRect * _arg1;
2122     PyObject * _argo0 = 0;
2123     wxRect  temp;
2124     PyObject * _obj1 = 0;
2125     char *_kwnames[] = { "self","rect", NULL };
2126
2127     self = self;
2128     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetSize",_kwnames,&_argo0,&_obj1))
2129         return NULL;
2130     if (_argo0) {
2131         if (_argo0 == Py_None) { _arg0 = NULL; }
2132         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2133             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetSize. Expected _wxGridCellEditor_p.");
2134         return NULL;
2135         }
2136     }
2137 {
2138     _arg1 = &temp;
2139     if (! wxRect_helper(_obj1, &_arg1))
2140         return NULL;
2141 }
2142 {
2143     wxPy_BEGIN_ALLOW_THREADS;
2144         wxGridCellEditor_SetSize(_arg0,*_arg1);
2145
2146     wxPy_END_ALLOW_THREADS;
2147     if (PyErr_Occurred()) return NULL;
2148 }    Py_INCREF(Py_None);
2149     _resultobj = Py_None;
2150     return _resultobj;
2151 }
2152
2153 #define wxGridCellEditor_Show(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Show(_swigarg0,_swigarg1))
2154 static PyObject *_wrap_wxGridCellEditor_Show(PyObject *self, PyObject *args, PyObject *kwargs) {
2155     PyObject * _resultobj;
2156     wxGridCellEditor * _arg0;
2157     bool  _arg1;
2158     wxGridCellAttr * _arg2 = (wxGridCellAttr *) NULL;
2159     PyObject * _argo0 = 0;
2160     int tempbool1;
2161     PyObject * _argo2 = 0;
2162     char *_kwnames[] = { "self","show","attr", NULL };
2163
2164     self = self;
2165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|O:wxGridCellEditor_Show",_kwnames,&_argo0,&tempbool1,&_argo2))
2166         return NULL;
2167     if (_argo0) {
2168         if (_argo0 == Py_None) { _arg0 = NULL; }
2169         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2170             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Show. Expected _wxGridCellEditor_p.");
2171         return NULL;
2172         }
2173     }
2174     _arg1 = (bool ) tempbool1;
2175     if (_argo2) {
2176         if (_argo2 == Py_None) { _arg2 = NULL; }
2177         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2178             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellEditor_Show. Expected _wxGridCellAttr_p.");
2179         return NULL;
2180         }
2181     }
2182 {
2183     wxPy_BEGIN_ALLOW_THREADS;
2184         wxGridCellEditor_Show(_arg0,_arg1,_arg2);
2185
2186     wxPy_END_ALLOW_THREADS;
2187     if (PyErr_Occurred()) return NULL;
2188 }    Py_INCREF(Py_None);
2189     _resultobj = Py_None;
2190     return _resultobj;
2191 }
2192
2193 #define wxGridCellEditor_PaintBackground(_swigobj,_swigarg0,_swigarg1)  (_swigobj->PaintBackground(_swigarg0,_swigarg1))
2194 static PyObject *_wrap_wxGridCellEditor_PaintBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
2195     PyObject * _resultobj;
2196     wxGridCellEditor * _arg0;
2197     wxRect * _arg1;
2198     wxGridCellAttr * _arg2;
2199     PyObject * _argo0 = 0;
2200     wxRect  temp;
2201     PyObject * _obj1 = 0;
2202     PyObject * _argo2 = 0;
2203     char *_kwnames[] = { "self","rectCell","attr", NULL };
2204
2205     self = self;
2206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGridCellEditor_PaintBackground",_kwnames,&_argo0,&_obj1,&_argo2))
2207         return NULL;
2208     if (_argo0) {
2209         if (_argo0 == Py_None) { _arg0 = NULL; }
2210         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2211             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_PaintBackground. Expected _wxGridCellEditor_p.");
2212         return NULL;
2213         }
2214     }
2215 {
2216     _arg1 = &temp;
2217     if (! wxRect_helper(_obj1, &_arg1))
2218         return NULL;
2219 }
2220     if (_argo2) {
2221         if (_argo2 == Py_None) { _arg2 = NULL; }
2222         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2223             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellEditor_PaintBackground. Expected _wxGridCellAttr_p.");
2224         return NULL;
2225         }
2226     }
2227 {
2228     wxPy_BEGIN_ALLOW_THREADS;
2229         wxGridCellEditor_PaintBackground(_arg0,*_arg1,_arg2);
2230
2231     wxPy_END_ALLOW_THREADS;
2232     if (PyErr_Occurred()) return NULL;
2233 }    Py_INCREF(Py_None);
2234     _resultobj = Py_None;
2235     return _resultobj;
2236 }
2237
2238 #define wxGridCellEditor_IsAcceptedKey(_swigobj,_swigarg0)  (_swigobj->IsAcceptedKey(_swigarg0))
2239 static PyObject *_wrap_wxGridCellEditor_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2240     PyObject * _resultobj;
2241     bool  _result;
2242     wxGridCellEditor * _arg0;
2243     wxKeyEvent * _arg1;
2244     PyObject * _argo0 = 0;
2245     PyObject * _argo1 = 0;
2246     char *_kwnames[] = { "self","event", NULL };
2247
2248     self = self;
2249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_IsAcceptedKey",_kwnames,&_argo0,&_argo1))
2250         return NULL;
2251     if (_argo0) {
2252         if (_argo0 == Py_None) { _arg0 = NULL; }
2253         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2254             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IsAcceptedKey. Expected _wxGridCellEditor_p.");
2255         return NULL;
2256         }
2257     }
2258     if (_argo1) {
2259         if (_argo1 == Py_None) { _arg1 = NULL; }
2260         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2261             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_IsAcceptedKey. Expected _wxKeyEvent_p.");
2262         return NULL;
2263         }
2264     }
2265 {
2266     wxPy_BEGIN_ALLOW_THREADS;
2267         _result = (bool )wxGridCellEditor_IsAcceptedKey(_arg0,*_arg1);
2268
2269     wxPy_END_ALLOW_THREADS;
2270     if (PyErr_Occurred()) return NULL;
2271 }    _resultobj = Py_BuildValue("i",_result);
2272     return _resultobj;
2273 }
2274
2275 #define wxGridCellEditor_StartingKey(_swigobj,_swigarg0)  (_swigobj->StartingKey(_swigarg0))
2276 static PyObject *_wrap_wxGridCellEditor_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2277     PyObject * _resultobj;
2278     wxGridCellEditor * _arg0;
2279     wxKeyEvent * _arg1;
2280     PyObject * _argo0 = 0;
2281     PyObject * _argo1 = 0;
2282     char *_kwnames[] = { "self","event", NULL };
2283
2284     self = self;
2285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_StartingKey",_kwnames,&_argo0,&_argo1))
2286         return NULL;
2287     if (_argo0) {
2288         if (_argo0 == Py_None) { _arg0 = NULL; }
2289         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2290             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_StartingKey. Expected _wxGridCellEditor_p.");
2291         return NULL;
2292         }
2293     }
2294     if (_argo1) {
2295         if (_argo1 == Py_None) { _arg1 = NULL; }
2296         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2297             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_StartingKey. Expected _wxKeyEvent_p.");
2298         return NULL;
2299         }
2300     }
2301 {
2302     wxPy_BEGIN_ALLOW_THREADS;
2303         wxGridCellEditor_StartingKey(_arg0,*_arg1);
2304
2305     wxPy_END_ALLOW_THREADS;
2306     if (PyErr_Occurred()) return NULL;
2307 }    Py_INCREF(Py_None);
2308     _resultobj = Py_None;
2309     return _resultobj;
2310 }
2311
2312 #define wxGridCellEditor_StartingClick(_swigobj)  (_swigobj->StartingClick())
2313 static PyObject *_wrap_wxGridCellEditor_StartingClick(PyObject *self, PyObject *args, PyObject *kwargs) {
2314     PyObject * _resultobj;
2315     wxGridCellEditor * _arg0;
2316     PyObject * _argo0 = 0;
2317     char *_kwnames[] = { "self", NULL };
2318
2319     self = self;
2320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_StartingClick",_kwnames,&_argo0))
2321         return NULL;
2322     if (_argo0) {
2323         if (_argo0 == Py_None) { _arg0 = NULL; }
2324         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2325             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_StartingClick. Expected _wxGridCellEditor_p.");
2326         return NULL;
2327         }
2328     }
2329 {
2330     wxPy_BEGIN_ALLOW_THREADS;
2331         wxGridCellEditor_StartingClick(_arg0);
2332
2333     wxPy_END_ALLOW_THREADS;
2334     if (PyErr_Occurred()) return NULL;
2335 }    Py_INCREF(Py_None);
2336     _resultobj = Py_None;
2337     return _resultobj;
2338 }
2339
2340 #define wxGridCellEditor_HandleReturn(_swigobj,_swigarg0)  (_swigobj->HandleReturn(_swigarg0))
2341 static PyObject *_wrap_wxGridCellEditor_HandleReturn(PyObject *self, PyObject *args, PyObject *kwargs) {
2342     PyObject * _resultobj;
2343     wxGridCellEditor * _arg0;
2344     wxKeyEvent * _arg1;
2345     PyObject * _argo0 = 0;
2346     PyObject * _argo1 = 0;
2347     char *_kwnames[] = { "self","event", NULL };
2348
2349     self = self;
2350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_HandleReturn",_kwnames,&_argo0,&_argo1))
2351         return NULL;
2352     if (_argo0) {
2353         if (_argo0 == Py_None) { _arg0 = NULL; }
2354         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2355             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_HandleReturn. Expected _wxGridCellEditor_p.");
2356         return NULL;
2357         }
2358     }
2359     if (_argo1) {
2360         if (_argo1 == Py_None) { _arg1 = NULL; }
2361         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2362             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_HandleReturn. Expected _wxKeyEvent_p.");
2363         return NULL;
2364         }
2365     }
2366 {
2367     wxPy_BEGIN_ALLOW_THREADS;
2368         wxGridCellEditor_HandleReturn(_arg0,*_arg1);
2369
2370     wxPy_END_ALLOW_THREADS;
2371     if (PyErr_Occurred()) return NULL;
2372 }    Py_INCREF(Py_None);
2373     _resultobj = Py_None;
2374     return _resultobj;
2375 }
2376
2377 #define wxGridCellEditor_Destroy(_swigobj)  (_swigobj->Destroy())
2378 static PyObject *_wrap_wxGridCellEditor_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
2379     PyObject * _resultobj;
2380     wxGridCellEditor * _arg0;
2381     PyObject * _argo0 = 0;
2382     char *_kwnames[] = { "self", NULL };
2383
2384     self = self;
2385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Destroy",_kwnames,&_argo0))
2386         return NULL;
2387     if (_argo0) {
2388         if (_argo0 == Py_None) { _arg0 = NULL; }
2389         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2390             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Destroy. Expected _wxGridCellEditor_p.");
2391         return NULL;
2392         }
2393     }
2394 {
2395     wxPy_BEGIN_ALLOW_THREADS;
2396         wxGridCellEditor_Destroy(_arg0);
2397
2398     wxPy_END_ALLOW_THREADS;
2399     if (PyErr_Occurred()) return NULL;
2400 }    Py_INCREF(Py_None);
2401     _resultobj = Py_None;
2402     return _resultobj;
2403 }
2404
2405 static void *SwigwxPyGridCellEditorTowxGridCellEditor(void *ptr) {
2406     wxPyGridCellEditor *src;
2407     wxGridCellEditor *dest;
2408     src = (wxPyGridCellEditor *) ptr;
2409     dest = (wxGridCellEditor *) src;
2410     return (void *) dest;
2411 }
2412
2413 #define new_wxPyGridCellEditor() (new wxPyGridCellEditor())
2414 static PyObject *_wrap_new_wxPyGridCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2415     PyObject * _resultobj;
2416     wxPyGridCellEditor * _result;
2417     char *_kwnames[] = {  NULL };
2418     char _ptemp[128];
2419
2420     self = self;
2421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellEditor",_kwnames))
2422         return NULL;
2423 {
2424     wxPy_BEGIN_ALLOW_THREADS;
2425         _result = (wxPyGridCellEditor *)new_wxPyGridCellEditor();
2426
2427     wxPy_END_ALLOW_THREADS;
2428     if (PyErr_Occurred()) return NULL;
2429 }    if (_result) {
2430         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellEditor_p");
2431         _resultobj = Py_BuildValue("s",_ptemp);
2432     } else {
2433         Py_INCREF(Py_None);
2434         _resultobj = Py_None;
2435     }
2436     return _resultobj;
2437 }
2438
2439 #define wxPyGridCellEditor__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
2440 static PyObject *_wrap_wxPyGridCellEditor__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
2441     PyObject * _resultobj;
2442     wxPyGridCellEditor * _arg0;
2443     PyObject * _arg1;
2444     PyObject * _arg2;
2445     PyObject * _argo0 = 0;
2446     PyObject * _obj1 = 0;
2447     PyObject * _obj2 = 0;
2448     char *_kwnames[] = { "self","self","_class", NULL };
2449
2450     self = self;
2451     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
2452         return NULL;
2453     if (_argo0) {
2454         if (_argo0 == Py_None) { _arg0 = NULL; }
2455         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2456             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor__setCallbackInfo. Expected _wxPyGridCellEditor_p.");
2457         return NULL;
2458         }
2459     }
2460 {
2461   _arg1 = _obj1;
2462 }
2463 {
2464   _arg2 = _obj2;
2465 }
2466 {
2467     wxPy_BEGIN_ALLOW_THREADS;
2468         wxPyGridCellEditor__setCallbackInfo(_arg0,_arg1,_arg2);
2469
2470     wxPy_END_ALLOW_THREADS;
2471     if (PyErr_Occurred()) return NULL;
2472 }    Py_INCREF(Py_None);
2473     _resultobj = Py_None;
2474     return _resultobj;
2475 }
2476
2477 #define wxPyGridCellEditor_base_SetSize(_swigobj,_swigarg0)  (_swigobj->base_SetSize(_swigarg0))
2478 static PyObject *_wrap_wxPyGridCellEditor_base_SetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
2479     PyObject * _resultobj;
2480     wxPyGridCellEditor * _arg0;
2481     wxRect * _arg1;
2482     PyObject * _argo0 = 0;
2483     wxRect  temp;
2484     PyObject * _obj1 = 0;
2485     char *_kwnames[] = { "self","rect", NULL };
2486
2487     self = self;
2488     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_SetSize",_kwnames,&_argo0,&_obj1))
2489         return NULL;
2490     if (_argo0) {
2491         if (_argo0 == Py_None) { _arg0 = NULL; }
2492         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2493             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_SetSize. Expected _wxPyGridCellEditor_p.");
2494         return NULL;
2495         }
2496     }
2497 {
2498     _arg1 = &temp;
2499     if (! wxRect_helper(_obj1, &_arg1))
2500         return NULL;
2501 }
2502 {
2503     wxPy_BEGIN_ALLOW_THREADS;
2504         wxPyGridCellEditor_base_SetSize(_arg0,*_arg1);
2505
2506     wxPy_END_ALLOW_THREADS;
2507     if (PyErr_Occurred()) return NULL;
2508 }    Py_INCREF(Py_None);
2509     _resultobj = Py_None;
2510     return _resultobj;
2511 }
2512
2513 #define wxPyGridCellEditor_base_Show(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_Show(_swigarg0,_swigarg1))
2514 static PyObject *_wrap_wxPyGridCellEditor_base_Show(PyObject *self, PyObject *args, PyObject *kwargs) {
2515     PyObject * _resultobj;
2516     wxPyGridCellEditor * _arg0;
2517     bool  _arg1;
2518     wxGridCellAttr * _arg2 = (wxGridCellAttr *) NULL;
2519     PyObject * _argo0 = 0;
2520     int tempbool1;
2521     PyObject * _argo2 = 0;
2522     char *_kwnames[] = { "self","show","attr", NULL };
2523
2524     self = self;
2525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|O:wxPyGridCellEditor_base_Show",_kwnames,&_argo0,&tempbool1,&_argo2))
2526         return NULL;
2527     if (_argo0) {
2528         if (_argo0 == Py_None) { _arg0 = NULL; }
2529         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2530             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_Show. Expected _wxPyGridCellEditor_p.");
2531         return NULL;
2532         }
2533     }
2534     _arg1 = (bool ) tempbool1;
2535     if (_argo2) {
2536         if (_argo2 == Py_None) { _arg2 = NULL; }
2537         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2538             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPyGridCellEditor_base_Show. Expected _wxGridCellAttr_p.");
2539         return NULL;
2540         }
2541     }
2542 {
2543     wxPy_BEGIN_ALLOW_THREADS;
2544         wxPyGridCellEditor_base_Show(_arg0,_arg1,_arg2);
2545
2546     wxPy_END_ALLOW_THREADS;
2547     if (PyErr_Occurred()) return NULL;
2548 }    Py_INCREF(Py_None);
2549     _resultobj = Py_None;
2550     return _resultobj;
2551 }
2552
2553 #define wxPyGridCellEditor_base_PaintBackground(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_PaintBackground(_swigarg0,_swigarg1))
2554 static PyObject *_wrap_wxPyGridCellEditor_base_PaintBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
2555     PyObject * _resultobj;
2556     wxPyGridCellEditor * _arg0;
2557     wxRect * _arg1;
2558     wxGridCellAttr * _arg2;
2559     PyObject * _argo0 = 0;
2560     wxRect  temp;
2561     PyObject * _obj1 = 0;
2562     PyObject * _argo2 = 0;
2563     char *_kwnames[] = { "self","rectCell","attr", NULL };
2564
2565     self = self;
2566     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor_base_PaintBackground",_kwnames,&_argo0,&_obj1,&_argo2))
2567         return NULL;
2568     if (_argo0) {
2569         if (_argo0 == Py_None) { _arg0 = NULL; }
2570         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2571             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_PaintBackground. Expected _wxPyGridCellEditor_p.");
2572         return NULL;
2573         }
2574     }
2575 {
2576     _arg1 = &temp;
2577     if (! wxRect_helper(_obj1, &_arg1))
2578         return NULL;
2579 }
2580     if (_argo2) {
2581         if (_argo2 == Py_None) { _arg2 = NULL; }
2582         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2583             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPyGridCellEditor_base_PaintBackground. Expected _wxGridCellAttr_p.");
2584         return NULL;
2585         }
2586     }
2587 {
2588     wxPy_BEGIN_ALLOW_THREADS;
2589         wxPyGridCellEditor_base_PaintBackground(_arg0,*_arg1,_arg2);
2590
2591     wxPy_END_ALLOW_THREADS;
2592     if (PyErr_Occurred()) return NULL;
2593 }    Py_INCREF(Py_None);
2594     _resultobj = Py_None;
2595     return _resultobj;
2596 }
2597
2598 #define wxPyGridCellEditor_base_IsAcceptedKey(_swigobj,_swigarg0)  (_swigobj->base_IsAcceptedKey(_swigarg0))
2599 static PyObject *_wrap_wxPyGridCellEditor_base_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2600     PyObject * _resultobj;
2601     wxPyGridCellEditor * _arg0;
2602     wxKeyEvent * _arg1;
2603     PyObject * _argo0 = 0;
2604     PyObject * _argo1 = 0;
2605     char *_kwnames[] = { "self","event", NULL };
2606
2607     self = self;
2608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_IsAcceptedKey",_kwnames,&_argo0,&_argo1))
2609         return NULL;
2610     if (_argo0) {
2611         if (_argo0 == Py_None) { _arg0 = NULL; }
2612         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2613             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxPyGridCellEditor_p.");
2614         return NULL;
2615         }
2616     }
2617     if (_argo1) {
2618         if (_argo1 == Py_None) { _arg1 = NULL; }
2619         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2620             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxKeyEvent_p.");
2621         return NULL;
2622         }
2623     }
2624 {
2625     wxPy_BEGIN_ALLOW_THREADS;
2626         wxPyGridCellEditor_base_IsAcceptedKey(_arg0,*_arg1);
2627
2628     wxPy_END_ALLOW_THREADS;
2629     if (PyErr_Occurred()) return NULL;
2630 }    Py_INCREF(Py_None);
2631     _resultobj = Py_None;
2632     return _resultobj;
2633 }
2634
2635 #define wxPyGridCellEditor_base_StartingKey(_swigobj,_swigarg0)  (_swigobj->base_StartingKey(_swigarg0))
2636 static PyObject *_wrap_wxPyGridCellEditor_base_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2637     PyObject * _resultobj;
2638     wxPyGridCellEditor * _arg0;
2639     wxKeyEvent * _arg1;
2640     PyObject * _argo0 = 0;
2641     PyObject * _argo1 = 0;
2642     char *_kwnames[] = { "self","event", NULL };
2643
2644     self = self;
2645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_StartingKey",_kwnames,&_argo0,&_argo1))
2646         return NULL;
2647     if (_argo0) {
2648         if (_argo0 == Py_None) { _arg0 = NULL; }
2649         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2650             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_StartingKey. Expected _wxPyGridCellEditor_p.");
2651         return NULL;
2652         }
2653     }
2654     if (_argo1) {
2655         if (_argo1 == Py_None) { _arg1 = NULL; }
2656         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2657             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_StartingKey. Expected _wxKeyEvent_p.");
2658         return NULL;
2659         }
2660     }
2661 {
2662     wxPy_BEGIN_ALLOW_THREADS;
2663         wxPyGridCellEditor_base_StartingKey(_arg0,*_arg1);
2664
2665     wxPy_END_ALLOW_THREADS;
2666     if (PyErr_Occurred()) return NULL;
2667 }    Py_INCREF(Py_None);
2668     _resultobj = Py_None;
2669     return _resultobj;
2670 }
2671
2672 #define wxPyGridCellEditor_base_StartingClick(_swigobj)  (_swigobj->base_StartingClick())
2673 static PyObject *_wrap_wxPyGridCellEditor_base_StartingClick(PyObject *self, PyObject *args, PyObject *kwargs) {
2674     PyObject * _resultobj;
2675     wxPyGridCellEditor * _arg0;
2676     PyObject * _argo0 = 0;
2677     char *_kwnames[] = { "self", NULL };
2678
2679     self = self;
2680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridCellEditor_base_StartingClick",_kwnames,&_argo0))
2681         return NULL;
2682     if (_argo0) {
2683         if (_argo0 == Py_None) { _arg0 = NULL; }
2684         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2685             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_StartingClick. Expected _wxPyGridCellEditor_p.");
2686         return NULL;
2687         }
2688     }
2689 {
2690     wxPy_BEGIN_ALLOW_THREADS;
2691         wxPyGridCellEditor_base_StartingClick(_arg0);
2692
2693     wxPy_END_ALLOW_THREADS;
2694     if (PyErr_Occurred()) return NULL;
2695 }    Py_INCREF(Py_None);
2696     _resultobj = Py_None;
2697     return _resultobj;
2698 }
2699
2700 #define wxPyGridCellEditor_base_HandleReturn(_swigobj,_swigarg0)  (_swigobj->base_HandleReturn(_swigarg0))
2701 static PyObject *_wrap_wxPyGridCellEditor_base_HandleReturn(PyObject *self, PyObject *args, PyObject *kwargs) {
2702     PyObject * _resultobj;
2703     wxPyGridCellEditor * _arg0;
2704     wxKeyEvent * _arg1;
2705     PyObject * _argo0 = 0;
2706     PyObject * _argo1 = 0;
2707     char *_kwnames[] = { "self","event", NULL };
2708
2709     self = self;
2710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_HandleReturn",_kwnames,&_argo0,&_argo1))
2711         return NULL;
2712     if (_argo0) {
2713         if (_argo0 == Py_None) { _arg0 = NULL; }
2714         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2715             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_HandleReturn. Expected _wxPyGridCellEditor_p.");
2716         return NULL;
2717         }
2718     }
2719     if (_argo1) {
2720         if (_argo1 == Py_None) { _arg1 = NULL; }
2721         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2722             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_HandleReturn. Expected _wxKeyEvent_p.");
2723         return NULL;
2724         }
2725     }
2726 {
2727     wxPy_BEGIN_ALLOW_THREADS;
2728         wxPyGridCellEditor_base_HandleReturn(_arg0,*_arg1);
2729
2730     wxPy_END_ALLOW_THREADS;
2731     if (PyErr_Occurred()) return NULL;
2732 }    Py_INCREF(Py_None);
2733     _resultobj = Py_None;
2734     return _resultobj;
2735 }
2736
2737 #define wxPyGridCellEditor_base_Destroy(_swigobj)  (_swigobj->base_Destroy())
2738 static PyObject *_wrap_wxPyGridCellEditor_base_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
2739     PyObject * _resultobj;
2740     wxPyGridCellEditor * _arg0;
2741     PyObject * _argo0 = 0;
2742     char *_kwnames[] = { "self", NULL };
2743
2744     self = self;
2745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridCellEditor_base_Destroy",_kwnames,&_argo0))
2746         return NULL;
2747     if (_argo0) {
2748         if (_argo0 == Py_None) { _arg0 = NULL; }
2749         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2750             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_Destroy. Expected _wxPyGridCellEditor_p.");
2751         return NULL;
2752         }
2753     }
2754 {
2755     wxPy_BEGIN_ALLOW_THREADS;
2756         wxPyGridCellEditor_base_Destroy(_arg0);
2757
2758     wxPy_END_ALLOW_THREADS;
2759     if (PyErr_Occurred()) return NULL;
2760 }    Py_INCREF(Py_None);
2761     _resultobj = Py_None;
2762     return _resultobj;
2763 }
2764
2765 #define wxPyGridCellEditor_base_SetParameters(_swigobj,_swigarg0)  (_swigobj->base_SetParameters(_swigarg0))
2766 static PyObject *_wrap_wxPyGridCellEditor_base_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
2767     PyObject * _resultobj;
2768     wxPyGridCellEditor * _arg0;
2769     wxString * _arg1;
2770     PyObject * _argo0 = 0;
2771     PyObject * _obj1 = 0;
2772     char *_kwnames[] = { "self","params", NULL };
2773
2774     self = self;
2775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_SetParameters",_kwnames,&_argo0,&_obj1))
2776         return NULL;
2777     if (_argo0) {
2778         if (_argo0 == Py_None) { _arg0 = NULL; }
2779         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2780             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_SetParameters. Expected _wxPyGridCellEditor_p.");
2781         return NULL;
2782         }
2783     }
2784 {
2785 #if PYTHON_API_VERSION >= 1009
2786     char* tmpPtr; int tmpSize;
2787     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2788         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2789         return NULL;
2790     }
2791     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2792         return NULL;
2793     _arg1 = new wxString(tmpPtr, tmpSize);
2794 #else
2795     if (!PyString_Check(_obj1)) {
2796         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2797         return NULL;
2798     }
2799     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2800 #endif
2801 }
2802 {
2803     wxPy_BEGIN_ALLOW_THREADS;
2804         wxPyGridCellEditor_base_SetParameters(_arg0,*_arg1);
2805
2806     wxPy_END_ALLOW_THREADS;
2807     if (PyErr_Occurred()) return NULL;
2808 }    Py_INCREF(Py_None);
2809     _resultobj = Py_None;
2810 {
2811     if (_obj1)
2812         delete _arg1;
2813 }
2814     return _resultobj;
2815 }
2816
2817 static void *SwigwxGridCellTextEditorTowxGridCellEditor(void *ptr) {
2818     wxGridCellTextEditor *src;
2819     wxGridCellEditor *dest;
2820     src = (wxGridCellTextEditor *) ptr;
2821     dest = (wxGridCellEditor *) src;
2822     return (void *) dest;
2823 }
2824
2825 #define new_wxGridCellTextEditor() (new wxGridCellTextEditor())
2826 static PyObject *_wrap_new_wxGridCellTextEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2827     PyObject * _resultobj;
2828     wxGridCellTextEditor * _result;
2829     char *_kwnames[] = {  NULL };
2830     char _ptemp[128];
2831
2832     self = self;
2833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellTextEditor",_kwnames))
2834         return NULL;
2835 {
2836     wxPy_BEGIN_ALLOW_THREADS;
2837         _result = (wxGridCellTextEditor *)new_wxGridCellTextEditor();
2838
2839     wxPy_END_ALLOW_THREADS;
2840     if (PyErr_Occurred()) return NULL;
2841 }    if (_result) {
2842         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellTextEditor_p");
2843         _resultobj = Py_BuildValue("s",_ptemp);
2844     } else {
2845         Py_INCREF(Py_None);
2846         _resultobj = Py_None;
2847     }
2848     return _resultobj;
2849 }
2850
2851 static void *SwigwxGridCellNumberEditorTowxGridCellTextEditor(void *ptr) {
2852     wxGridCellNumberEditor *src;
2853     wxGridCellTextEditor *dest;
2854     src = (wxGridCellNumberEditor *) ptr;
2855     dest = (wxGridCellTextEditor *) src;
2856     return (void *) dest;
2857 }
2858
2859 static void *SwigwxGridCellNumberEditorTowxGridCellEditor(void *ptr) {
2860     wxGridCellNumberEditor *src;
2861     wxGridCellEditor *dest;
2862     src = (wxGridCellNumberEditor *) ptr;
2863     dest = (wxGridCellEditor *) src;
2864     return (void *) dest;
2865 }
2866
2867 #define new_wxGridCellNumberEditor(_swigarg0,_swigarg1) (new wxGridCellNumberEditor(_swigarg0,_swigarg1))
2868 static PyObject *_wrap_new_wxGridCellNumberEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2869     PyObject * _resultobj;
2870     wxGridCellNumberEditor * _result;
2871     int  _arg0 = (int ) -1;
2872     int  _arg1 = (int ) -1;
2873     char *_kwnames[] = { "min","max", NULL };
2874     char _ptemp[128];
2875
2876     self = self;
2877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellNumberEditor",_kwnames,&_arg0,&_arg1))
2878         return NULL;
2879 {
2880     wxPy_BEGIN_ALLOW_THREADS;
2881         _result = (wxGridCellNumberEditor *)new_wxGridCellNumberEditor(_arg0,_arg1);
2882
2883     wxPy_END_ALLOW_THREADS;
2884     if (PyErr_Occurred()) return NULL;
2885 }    if (_result) {
2886         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberEditor_p");
2887         _resultobj = Py_BuildValue("s",_ptemp);
2888     } else {
2889         Py_INCREF(Py_None);
2890         _resultobj = Py_None;
2891     }
2892     return _resultobj;
2893 }
2894
2895 static void *SwigwxGridCellFloatEditorTowxGridCellTextEditor(void *ptr) {
2896     wxGridCellFloatEditor *src;
2897     wxGridCellTextEditor *dest;
2898     src = (wxGridCellFloatEditor *) ptr;
2899     dest = (wxGridCellTextEditor *) src;
2900     return (void *) dest;
2901 }
2902
2903 static void *SwigwxGridCellFloatEditorTowxGridCellEditor(void *ptr) {
2904     wxGridCellFloatEditor *src;
2905     wxGridCellEditor *dest;
2906     src = (wxGridCellFloatEditor *) ptr;
2907     dest = (wxGridCellEditor *) src;
2908     return (void *) dest;
2909 }
2910
2911 #define new_wxGridCellFloatEditor() (new wxGridCellFloatEditor())
2912 static PyObject *_wrap_new_wxGridCellFloatEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2913     PyObject * _resultobj;
2914     wxGridCellFloatEditor * _result;
2915     char *_kwnames[] = {  NULL };
2916     char _ptemp[128];
2917
2918     self = self;
2919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellFloatEditor",_kwnames))
2920         return NULL;
2921 {
2922     wxPy_BEGIN_ALLOW_THREADS;
2923         _result = (wxGridCellFloatEditor *)new_wxGridCellFloatEditor();
2924
2925     wxPy_END_ALLOW_THREADS;
2926     if (PyErr_Occurred()) return NULL;
2927 }    if (_result) {
2928         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatEditor_p");
2929         _resultobj = Py_BuildValue("s",_ptemp);
2930     } else {
2931         Py_INCREF(Py_None);
2932         _resultobj = Py_None;
2933     }
2934     return _resultobj;
2935 }
2936
2937 static void *SwigwxGridCellBoolEditorTowxGridCellEditor(void *ptr) {
2938     wxGridCellBoolEditor *src;
2939     wxGridCellEditor *dest;
2940     src = (wxGridCellBoolEditor *) ptr;
2941     dest = (wxGridCellEditor *) src;
2942     return (void *) dest;
2943 }
2944
2945 #define new_wxGridCellBoolEditor() (new wxGridCellBoolEditor())
2946 static PyObject *_wrap_new_wxGridCellBoolEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2947     PyObject * _resultobj;
2948     wxGridCellBoolEditor * _result;
2949     char *_kwnames[] = {  NULL };
2950     char _ptemp[128];
2951
2952     self = self;
2953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolEditor",_kwnames))
2954         return NULL;
2955 {
2956     wxPy_BEGIN_ALLOW_THREADS;
2957         _result = (wxGridCellBoolEditor *)new_wxGridCellBoolEditor();
2958
2959     wxPy_END_ALLOW_THREADS;
2960     if (PyErr_Occurred()) return NULL;
2961 }    if (_result) {
2962         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolEditor_p");
2963         _resultobj = Py_BuildValue("s",_ptemp);
2964     } else {
2965         Py_INCREF(Py_None);
2966         _resultobj = Py_None;
2967     }
2968     return _resultobj;
2969 }
2970
2971 static void *SwigwxGridCellChoiceEditorTowxGridCellEditor(void *ptr) {
2972     wxGridCellChoiceEditor *src;
2973     wxGridCellEditor *dest;
2974     src = (wxGridCellChoiceEditor *) ptr;
2975     dest = (wxGridCellEditor *) src;
2976     return (void *) dest;
2977 }
2978
2979 #define new_wxGridCellChoiceEditor(_swigarg0,_swigarg1,_swigarg2) (new wxGridCellChoiceEditor(_swigarg0,_swigarg1,_swigarg2))
2980 static PyObject *_wrap_new_wxGridCellChoiceEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2981     PyObject * _resultobj;
2982     wxGridCellChoiceEditor * _result;
2983     int  _arg0 = (int ) 0;
2984     wxString * _arg1 = (wxString *) NULL;
2985     bool  _arg2 = (bool ) FALSE;
2986     PyObject * _obj1 = 0;
2987     int tempbool2 = (int) FALSE;
2988     char *_kwnames[] = { "choices","allowOthers", NULL };
2989     char _ptemp[128];
2990
2991     self = self;
2992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|Oi:new_wxGridCellChoiceEditor",_kwnames,&_obj1,&tempbool2))
2993         return NULL;
2994     if (_obj1)
2995 {
2996     _arg1 = wxString_LIST_helper(_obj1);
2997     if (_arg1 == NULL) {
2998         return NULL;
2999     }
3000 }
3001     _arg2 = (bool ) tempbool2;
3002 {
3003     if (_obj1) {
3004         _arg0 = PyList_Size(_obj1);
3005     }
3006     else {
3007         _arg0 = 0;
3008     }
3009 }
3010 {
3011     wxPy_BEGIN_ALLOW_THREADS;
3012         _result = (wxGridCellChoiceEditor *)new_wxGridCellChoiceEditor(_arg0,_arg1,_arg2);
3013
3014     wxPy_END_ALLOW_THREADS;
3015     if (PyErr_Occurred()) return NULL;
3016 }    if (_result) {
3017         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellChoiceEditor_p");
3018         _resultobj = Py_BuildValue("s",_ptemp);
3019     } else {
3020         Py_INCREF(Py_None);
3021         _resultobj = Py_None;
3022     }
3023 {
3024     delete [] _arg1;
3025 }
3026     return _resultobj;
3027 }
3028
3029 static void *SwigwxGridCellEnumEditorTowxGridCellChoiceEditor(void *ptr) {
3030     wxGridCellEnumEditor *src;
3031     wxGridCellChoiceEditor *dest;
3032     src = (wxGridCellEnumEditor *) ptr;
3033     dest = (wxGridCellChoiceEditor *) src;
3034     return (void *) dest;
3035 }
3036
3037 static void *SwigwxGridCellEnumEditorTowxGridCellEditor(void *ptr) {
3038     wxGridCellEnumEditor *src;
3039     wxGridCellEditor *dest;
3040     src = (wxGridCellEnumEditor *) ptr;
3041     dest = (wxGridCellEditor *) src;
3042     return (void *) dest;
3043 }
3044
3045 #define new_wxGridCellEnumEditor(_swigarg0) (new wxGridCellEnumEditor(_swigarg0))
3046 static PyObject *_wrap_new_wxGridCellEnumEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3047     PyObject * _resultobj;
3048     wxGridCellEnumEditor * _result;
3049     wxString * _arg0 = (wxString *) &"";
3050     PyObject * _obj0 = 0;
3051     char *_kwnames[] = { "choices", NULL };
3052     char _ptemp[128];
3053
3054     self = self;
3055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxGridCellEnumEditor",_kwnames,&_obj0))
3056         return NULL;
3057     if (_obj0)
3058 {
3059     _arg0 = wxString_LIST_helper(_obj0);
3060     if (_arg0 == NULL) {
3061         return NULL;
3062     }
3063 }
3064 {
3065     wxPy_BEGIN_ALLOW_THREADS;
3066         _result = (wxGridCellEnumEditor *)new_wxGridCellEnumEditor(*_arg0);
3067
3068     wxPy_END_ALLOW_THREADS;
3069     if (PyErr_Occurred()) return NULL;
3070 }    if (_result) {
3071         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumEditor_p");
3072         _resultobj = Py_BuildValue("s",_ptemp);
3073     } else {
3074         Py_INCREF(Py_None);
3075         _resultobj = Py_None;
3076     }
3077 {
3078     delete [] _arg0;
3079 }
3080     return _resultobj;
3081 }
3082
3083 static void *SwigwxGridCellAutoWrapStringEditorTowxGridCellTextEditor(void *ptr) {
3084     wxGridCellAutoWrapStringEditor *src;
3085     wxGridCellTextEditor *dest;
3086     src = (wxGridCellAutoWrapStringEditor *) ptr;
3087     dest = (wxGridCellTextEditor *) src;
3088     return (void *) dest;
3089 }
3090
3091 static void *SwigwxGridCellAutoWrapStringEditorTowxGridCellEditor(void *ptr) {
3092     wxGridCellAutoWrapStringEditor *src;
3093     wxGridCellEditor *dest;
3094     src = (wxGridCellAutoWrapStringEditor *) ptr;
3095     dest = (wxGridCellEditor *) src;
3096     return (void *) dest;
3097 }
3098
3099 #define new_wxGridCellAutoWrapStringEditor() (new wxGridCellAutoWrapStringEditor())
3100 static PyObject *_wrap_new_wxGridCellAutoWrapStringEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3101     PyObject * _resultobj;
3102     wxGridCellAutoWrapStringEditor * _result;
3103     char *_kwnames[] = {  NULL };
3104     char _ptemp[128];
3105
3106     self = self;
3107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringEditor",_kwnames))
3108         return NULL;
3109 {
3110     wxPy_BEGIN_ALLOW_THREADS;
3111         _result = (wxGridCellAutoWrapStringEditor *)new_wxGridCellAutoWrapStringEditor();
3112
3113     wxPy_END_ALLOW_THREADS;
3114     if (PyErr_Occurred()) return NULL;
3115 }    if (_result) {
3116         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringEditor_p");
3117         _resultobj = Py_BuildValue("s",_ptemp);
3118     } else {
3119         Py_INCREF(Py_None);
3120         _resultobj = Py_None;
3121     }
3122     return _resultobj;
3123 }
3124
3125 #define new_wxGridCellAttr() (new wxGridCellAttr())
3126 static PyObject *_wrap_new_wxGridCellAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
3127     PyObject * _resultobj;
3128     wxGridCellAttr * _result;
3129     char *_kwnames[] = {  NULL };
3130     char _ptemp[128];
3131
3132     self = self;
3133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttr",_kwnames))
3134         return NULL;
3135 {
3136     wxPy_BEGIN_ALLOW_THREADS;
3137         _result = (wxGridCellAttr *)new_wxGridCellAttr();
3138
3139     wxPy_END_ALLOW_THREADS;
3140     if (PyErr_Occurred()) return NULL;
3141 }    if (_result) {
3142         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
3143         _resultobj = Py_BuildValue("s",_ptemp);
3144     } else {
3145         Py_INCREF(Py_None);
3146         _resultobj = Py_None;
3147     }
3148     return _resultobj;
3149 }
3150
3151 #define wxGridCellAttr_Clone(_swigobj)  (_swigobj->Clone())
3152 static PyObject *_wrap_wxGridCellAttr_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
3153     PyObject * _resultobj;
3154     wxGridCellAttr * _result;
3155     wxGridCellAttr * _arg0;
3156     PyObject * _argo0 = 0;
3157     char *_kwnames[] = { "self", NULL };
3158     char _ptemp[128];
3159
3160     self = self;
3161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_Clone",_kwnames,&_argo0))
3162         return NULL;
3163     if (_argo0) {
3164         if (_argo0 == Py_None) { _arg0 = NULL; }
3165         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3166             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_Clone. Expected _wxGridCellAttr_p.");
3167         return NULL;
3168         }
3169     }
3170 {
3171     wxPy_BEGIN_ALLOW_THREADS;
3172         _result = (wxGridCellAttr *)wxGridCellAttr_Clone(_arg0);
3173
3174     wxPy_END_ALLOW_THREADS;
3175     if (PyErr_Occurred()) return NULL;
3176 }    if (_result) {
3177         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
3178         _resultobj = Py_BuildValue("s",_ptemp);
3179     } else {
3180         Py_INCREF(Py_None);
3181         _resultobj = Py_None;
3182     }
3183     return _resultobj;
3184 }
3185
3186 #define wxGridCellAttr_MergeWith(_swigobj,_swigarg0)  (_swigobj->MergeWith(_swigarg0))
3187 static PyObject *_wrap_wxGridCellAttr_MergeWith(PyObject *self, PyObject *args, PyObject *kwargs) {
3188     PyObject * _resultobj;
3189     wxGridCellAttr * _arg0;
3190     wxGridCellAttr * _arg1;
3191     PyObject * _argo0 = 0;
3192     PyObject * _argo1 = 0;
3193     char *_kwnames[] = { "self","mergefrom", NULL };
3194
3195     self = self;
3196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_MergeWith",_kwnames,&_argo0,&_argo1))
3197         return NULL;
3198     if (_argo0) {
3199         if (_argo0 == Py_None) { _arg0 = NULL; }
3200         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3201             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_MergeWith. Expected _wxGridCellAttr_p.");
3202         return NULL;
3203         }
3204     }
3205     if (_argo1) {
3206         if (_argo1 == Py_None) { _arg1 = NULL; }
3207         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
3208             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_MergeWith. Expected _wxGridCellAttr_p.");
3209         return NULL;
3210         }
3211     }
3212 {
3213     wxPy_BEGIN_ALLOW_THREADS;
3214         wxGridCellAttr_MergeWith(_arg0,_arg1);
3215
3216     wxPy_END_ALLOW_THREADS;
3217     if (PyErr_Occurred()) return NULL;
3218 }    Py_INCREF(Py_None);
3219     _resultobj = Py_None;
3220     return _resultobj;
3221 }
3222
3223 #define wxGridCellAttr_IncRef(_swigobj)  (_swigobj->IncRef())
3224 static PyObject *_wrap_wxGridCellAttr_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
3225     PyObject * _resultobj;
3226     wxGridCellAttr * _arg0;
3227     PyObject * _argo0 = 0;
3228     char *_kwnames[] = { "self", NULL };
3229
3230     self = self;
3231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_IncRef",_kwnames,&_argo0))
3232         return NULL;
3233     if (_argo0) {
3234         if (_argo0 == Py_None) { _arg0 = NULL; }
3235         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3236             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_IncRef. Expected _wxGridCellAttr_p.");
3237         return NULL;
3238         }
3239     }
3240 {
3241     wxPy_BEGIN_ALLOW_THREADS;
3242         wxGridCellAttr_IncRef(_arg0);
3243
3244     wxPy_END_ALLOW_THREADS;
3245     if (PyErr_Occurred()) return NULL;
3246 }    Py_INCREF(Py_None);
3247     _resultobj = Py_None;
3248     return _resultobj;
3249 }
3250
3251 #define wxGridCellAttr_DecRef(_swigobj)  (_swigobj->DecRef())
3252 static PyObject *_wrap_wxGridCellAttr_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
3253     PyObject * _resultobj;
3254     wxGridCellAttr * _arg0;
3255     PyObject * _argo0 = 0;
3256     char *_kwnames[] = { "self", NULL };
3257
3258     self = self;
3259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_DecRef",_kwnames,&_argo0))
3260         return NULL;
3261     if (_argo0) {
3262         if (_argo0 == Py_None) { _arg0 = NULL; }
3263         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3264             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_DecRef. Expected _wxGridCellAttr_p.");
3265         return NULL;
3266         }
3267     }
3268 {
3269     wxPy_BEGIN_ALLOW_THREADS;
3270         wxGridCellAttr_DecRef(_arg0);
3271
3272     wxPy_END_ALLOW_THREADS;
3273     if (PyErr_Occurred()) return NULL;
3274 }    Py_INCREF(Py_None);
3275     _resultobj = Py_None;
3276     return _resultobj;
3277 }
3278
3279 #define wxGridCellAttr_SetTextColour(_swigobj,_swigarg0)  (_swigobj->SetTextColour(_swigarg0))
3280 static PyObject *_wrap_wxGridCellAttr_SetTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3281     PyObject * _resultobj;
3282     wxGridCellAttr * _arg0;
3283     wxColour * _arg1;
3284     PyObject * _argo0 = 0;
3285     wxColour  temp;
3286     PyObject * _obj1 = 0;
3287     char *_kwnames[] = { "self","colText", NULL };
3288
3289     self = self;
3290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetTextColour",_kwnames,&_argo0,&_obj1))
3291         return NULL;
3292     if (_argo0) {
3293         if (_argo0 == Py_None) { _arg0 = NULL; }
3294         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3295             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetTextColour. Expected _wxGridCellAttr_p.");
3296         return NULL;
3297         }
3298     }
3299 {
3300     _arg1 = &temp;
3301     if (! wxColour_helper(_obj1, &_arg1))
3302         return NULL;
3303 }
3304 {
3305     wxPy_BEGIN_ALLOW_THREADS;
3306         wxGridCellAttr_SetTextColour(_arg0,*_arg1);
3307
3308     wxPy_END_ALLOW_THREADS;
3309     if (PyErr_Occurred()) return NULL;
3310 }    Py_INCREF(Py_None);
3311     _resultobj = Py_None;
3312     return _resultobj;
3313 }
3314
3315 #define wxGridCellAttr_SetBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetBackgroundColour(_swigarg0))
3316 static PyObject *_wrap_wxGridCellAttr_SetBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3317     PyObject * _resultobj;
3318     wxGridCellAttr * _arg0;
3319     wxColour * _arg1;
3320     PyObject * _argo0 = 0;
3321     wxColour  temp;
3322     PyObject * _obj1 = 0;
3323     char *_kwnames[] = { "self","colBack", NULL };
3324
3325     self = self;
3326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetBackgroundColour",_kwnames,&_argo0,&_obj1))
3327         return NULL;
3328     if (_argo0) {
3329         if (_argo0 == Py_None) { _arg0 = NULL; }
3330         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3331             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetBackgroundColour. Expected _wxGridCellAttr_p.");
3332         return NULL;
3333         }
3334     }
3335 {
3336     _arg1 = &temp;
3337     if (! wxColour_helper(_obj1, &_arg1))
3338         return NULL;
3339 }
3340 {
3341     wxPy_BEGIN_ALLOW_THREADS;
3342         wxGridCellAttr_SetBackgroundColour(_arg0,*_arg1);
3343
3344     wxPy_END_ALLOW_THREADS;
3345     if (PyErr_Occurred()) return NULL;
3346 }    Py_INCREF(Py_None);
3347     _resultobj = Py_None;
3348     return _resultobj;
3349 }
3350
3351 #define wxGridCellAttr_SetFont(_swigobj,_swigarg0)  (_swigobj->SetFont(_swigarg0))
3352 static PyObject *_wrap_wxGridCellAttr_SetFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3353     PyObject * _resultobj;
3354     wxGridCellAttr * _arg0;
3355     wxFont * _arg1;
3356     PyObject * _argo0 = 0;
3357     PyObject * _argo1 = 0;
3358     char *_kwnames[] = { "self","font", NULL };
3359
3360     self = self;
3361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetFont",_kwnames,&_argo0,&_argo1))
3362         return NULL;
3363     if (_argo0) {
3364         if (_argo0 == Py_None) { _arg0 = NULL; }
3365         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3366             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetFont. Expected _wxGridCellAttr_p.");
3367         return NULL;
3368         }
3369     }
3370     if (_argo1) {
3371         if (_argo1 == Py_None) { _arg1 = NULL; }
3372         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
3373             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetFont. Expected _wxFont_p.");
3374         return NULL;
3375         }
3376     }
3377 {
3378     wxPy_BEGIN_ALLOW_THREADS;
3379         wxGridCellAttr_SetFont(_arg0,*_arg1);
3380
3381     wxPy_END_ALLOW_THREADS;
3382     if (PyErr_Occurred()) return NULL;
3383 }    Py_INCREF(Py_None);
3384     _resultobj = Py_None;
3385     return _resultobj;
3386 }
3387
3388 #define wxGridCellAttr_SetAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetAlignment(_swigarg0,_swigarg1))
3389 static PyObject *_wrap_wxGridCellAttr_SetAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3390     PyObject * _resultobj;
3391     wxGridCellAttr * _arg0;
3392     int  _arg1;
3393     int  _arg2;
3394     PyObject * _argo0 = 0;
3395     char *_kwnames[] = { "self","hAlign","vAlign", NULL };
3396
3397     self = self;
3398     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttr_SetAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
3399         return NULL;
3400     if (_argo0) {
3401         if (_argo0 == Py_None) { _arg0 = NULL; }
3402         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3403             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetAlignment. Expected _wxGridCellAttr_p.");
3404         return NULL;
3405         }
3406     }
3407 {
3408     wxPy_BEGIN_ALLOW_THREADS;
3409         wxGridCellAttr_SetAlignment(_arg0,_arg1,_arg2);
3410
3411     wxPy_END_ALLOW_THREADS;
3412     if (PyErr_Occurred()) return NULL;
3413 }    Py_INCREF(Py_None);
3414     _resultobj = Py_None;
3415     return _resultobj;
3416 }
3417
3418 #define wxGridCellAttr_SetReadOnly(_swigobj,_swigarg0)  (_swigobj->SetReadOnly(_swigarg0))
3419 static PyObject *_wrap_wxGridCellAttr_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
3420     PyObject * _resultobj;
3421     wxGridCellAttr * _arg0;
3422     bool  _arg1 = (bool ) TRUE;
3423     PyObject * _argo0 = 0;
3424     int tempbool1 = (int) TRUE;
3425     char *_kwnames[] = { "self","isReadOnly", NULL };
3426
3427     self = self;
3428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridCellAttr_SetReadOnly",_kwnames,&_argo0,&tempbool1))
3429         return NULL;
3430     if (_argo0) {
3431         if (_argo0 == Py_None) { _arg0 = NULL; }
3432         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3433             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetReadOnly. Expected _wxGridCellAttr_p.");
3434         return NULL;
3435         }
3436     }
3437     _arg1 = (bool ) tempbool1;
3438 {
3439     wxPy_BEGIN_ALLOW_THREADS;
3440         wxGridCellAttr_SetReadOnly(_arg0,_arg1);
3441
3442     wxPy_END_ALLOW_THREADS;
3443     if (PyErr_Occurred()) return NULL;
3444 }    Py_INCREF(Py_None);
3445     _resultobj = Py_None;
3446     return _resultobj;
3447 }
3448
3449 #define wxGridCellAttr_SetRenderer(_swigobj,_swigarg0)  (_swigobj->SetRenderer(_swigarg0))
3450 static PyObject *_wrap_wxGridCellAttr_SetRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3451     PyObject * _resultobj;
3452     wxGridCellAttr * _arg0;
3453     wxGridCellRenderer * _arg1;
3454     PyObject * _argo0 = 0;
3455     PyObject * _argo1 = 0;
3456     char *_kwnames[] = { "self","renderer", NULL };
3457
3458     self = self;
3459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetRenderer",_kwnames,&_argo0,&_argo1))
3460         return NULL;
3461     if (_argo0) {
3462         if (_argo0 == Py_None) { _arg0 = NULL; }
3463         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3464             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetRenderer. Expected _wxGridCellAttr_p.");
3465         return NULL;
3466         }
3467     }
3468     if (_argo1) {
3469         if (_argo1 == Py_None) { _arg1 = NULL; }
3470         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellRenderer_p")) {
3471             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetRenderer. Expected _wxGridCellRenderer_p.");
3472         return NULL;
3473         }
3474     }
3475 {
3476     wxPy_BEGIN_ALLOW_THREADS;
3477         wxGridCellAttr_SetRenderer(_arg0,_arg1);
3478
3479     wxPy_END_ALLOW_THREADS;
3480     if (PyErr_Occurred()) return NULL;
3481 }    Py_INCREF(Py_None);
3482     _resultobj = Py_None;
3483     return _resultobj;
3484 }
3485
3486 #define wxGridCellAttr_SetEditor(_swigobj,_swigarg0)  (_swigobj->SetEditor(_swigarg0))
3487 static PyObject *_wrap_wxGridCellAttr_SetEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3488     PyObject * _resultobj;
3489     wxGridCellAttr * _arg0;
3490     wxGridCellEditor * _arg1;
3491     PyObject * _argo0 = 0;
3492     PyObject * _argo1 = 0;
3493     char *_kwnames[] = { "self","editor", NULL };
3494
3495     self = self;
3496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetEditor",_kwnames,&_argo0,&_argo1))
3497         return NULL;
3498     if (_argo0) {
3499         if (_argo0 == Py_None) { _arg0 = NULL; }
3500         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3501             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetEditor. Expected _wxGridCellAttr_p.");
3502         return NULL;
3503         }
3504     }
3505     if (_argo1) {
3506         if (_argo1 == Py_None) { _arg1 = NULL; }
3507         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellEditor_p")) {
3508             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetEditor. Expected _wxGridCellEditor_p.");
3509         return NULL;
3510         }
3511     }
3512 {
3513     wxPy_BEGIN_ALLOW_THREADS;
3514         wxGridCellAttr_SetEditor(_arg0,_arg1);
3515
3516     wxPy_END_ALLOW_THREADS;
3517     if (PyErr_Occurred()) return NULL;
3518 }    Py_INCREF(Py_None);
3519     _resultobj = Py_None;
3520     return _resultobj;
3521 }
3522
3523 #define wxGridCellAttr_SetKind(_swigobj,_swigarg0)  (_swigobj->SetKind(_swigarg0))
3524 static PyObject *_wrap_wxGridCellAttr_SetKind(PyObject *self, PyObject *args, PyObject *kwargs) {
3525     PyObject * _resultobj;
3526     wxGridCellAttr * _arg0;
3527     wxGridCellAttr::wxAttrKind  _arg1;
3528     PyObject * _argo0 = 0;
3529     char *_kwnames[] = { "self","kind", NULL };
3530
3531     self = self;
3532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellAttr_SetKind",_kwnames,&_argo0,&_arg1))
3533         return NULL;
3534     if (_argo0) {
3535         if (_argo0 == Py_None) { _arg0 = NULL; }
3536         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3537             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetKind. Expected _wxGridCellAttr_p.");
3538         return NULL;
3539         }
3540     }
3541 {
3542     wxPy_BEGIN_ALLOW_THREADS;
3543         wxGridCellAttr_SetKind(_arg0,_arg1);
3544
3545     wxPy_END_ALLOW_THREADS;
3546     if (PyErr_Occurred()) return NULL;
3547 }    Py_INCREF(Py_None);
3548     _resultobj = Py_None;
3549     return _resultobj;
3550 }
3551
3552 #define wxGridCellAttr_HasTextColour(_swigobj)  (_swigobj->HasTextColour())
3553 static PyObject *_wrap_wxGridCellAttr_HasTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3554     PyObject * _resultobj;
3555     bool  _result;
3556     wxGridCellAttr * _arg0;
3557     PyObject * _argo0 = 0;
3558     char *_kwnames[] = { "self", NULL };
3559
3560     self = self;
3561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasTextColour",_kwnames,&_argo0))
3562         return NULL;
3563     if (_argo0) {
3564         if (_argo0 == Py_None) { _arg0 = NULL; }
3565         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3566             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasTextColour. Expected _wxGridCellAttr_p.");
3567         return NULL;
3568         }
3569     }
3570 {
3571     wxPy_BEGIN_ALLOW_THREADS;
3572         _result = (bool )wxGridCellAttr_HasTextColour(_arg0);
3573
3574     wxPy_END_ALLOW_THREADS;
3575     if (PyErr_Occurred()) return NULL;
3576 }    _resultobj = Py_BuildValue("i",_result);
3577     return _resultobj;
3578 }
3579
3580 #define wxGridCellAttr_HasBackgroundColour(_swigobj)  (_swigobj->HasBackgroundColour())
3581 static PyObject *_wrap_wxGridCellAttr_HasBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3582     PyObject * _resultobj;
3583     bool  _result;
3584     wxGridCellAttr * _arg0;
3585     PyObject * _argo0 = 0;
3586     char *_kwnames[] = { "self", NULL };
3587
3588     self = self;
3589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasBackgroundColour",_kwnames,&_argo0))
3590         return NULL;
3591     if (_argo0) {
3592         if (_argo0 == Py_None) { _arg0 = NULL; }
3593         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3594             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasBackgroundColour. Expected _wxGridCellAttr_p.");
3595         return NULL;
3596         }
3597     }
3598 {
3599     wxPy_BEGIN_ALLOW_THREADS;
3600         _result = (bool )wxGridCellAttr_HasBackgroundColour(_arg0);
3601
3602     wxPy_END_ALLOW_THREADS;
3603     if (PyErr_Occurred()) return NULL;
3604 }    _resultobj = Py_BuildValue("i",_result);
3605     return _resultobj;
3606 }
3607
3608 #define wxGridCellAttr_HasFont(_swigobj)  (_swigobj->HasFont())
3609 static PyObject *_wrap_wxGridCellAttr_HasFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3610     PyObject * _resultobj;
3611     bool  _result;
3612     wxGridCellAttr * _arg0;
3613     PyObject * _argo0 = 0;
3614     char *_kwnames[] = { "self", NULL };
3615
3616     self = self;
3617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasFont",_kwnames,&_argo0))
3618         return NULL;
3619     if (_argo0) {
3620         if (_argo0 == Py_None) { _arg0 = NULL; }
3621         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3622             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasFont. Expected _wxGridCellAttr_p.");
3623         return NULL;
3624         }
3625     }
3626 {
3627     wxPy_BEGIN_ALLOW_THREADS;
3628         _result = (bool )wxGridCellAttr_HasFont(_arg0);
3629
3630     wxPy_END_ALLOW_THREADS;
3631     if (PyErr_Occurred()) return NULL;
3632 }    _resultobj = Py_BuildValue("i",_result);
3633     return _resultobj;
3634 }
3635
3636 #define wxGridCellAttr_HasAlignment(_swigobj)  (_swigobj->HasAlignment())
3637 static PyObject *_wrap_wxGridCellAttr_HasAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3638     PyObject * _resultobj;
3639     bool  _result;
3640     wxGridCellAttr * _arg0;
3641     PyObject * _argo0 = 0;
3642     char *_kwnames[] = { "self", NULL };
3643
3644     self = self;
3645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasAlignment",_kwnames,&_argo0))
3646         return NULL;
3647     if (_argo0) {
3648         if (_argo0 == Py_None) { _arg0 = NULL; }
3649         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3650             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasAlignment. Expected _wxGridCellAttr_p.");
3651         return NULL;
3652         }
3653     }
3654 {
3655     wxPy_BEGIN_ALLOW_THREADS;
3656         _result = (bool )wxGridCellAttr_HasAlignment(_arg0);
3657
3658     wxPy_END_ALLOW_THREADS;
3659     if (PyErr_Occurred()) return NULL;
3660 }    _resultobj = Py_BuildValue("i",_result);
3661     return _resultobj;
3662 }
3663
3664 #define wxGridCellAttr_HasRenderer(_swigobj)  (_swigobj->HasRenderer())
3665 static PyObject *_wrap_wxGridCellAttr_HasRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3666     PyObject * _resultobj;
3667     bool  _result;
3668     wxGridCellAttr * _arg0;
3669     PyObject * _argo0 = 0;
3670     char *_kwnames[] = { "self", NULL };
3671
3672     self = self;
3673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasRenderer",_kwnames,&_argo0))
3674         return NULL;
3675     if (_argo0) {
3676         if (_argo0 == Py_None) { _arg0 = NULL; }
3677         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3678             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasRenderer. Expected _wxGridCellAttr_p.");
3679         return NULL;
3680         }
3681     }
3682 {
3683     wxPy_BEGIN_ALLOW_THREADS;
3684         _result = (bool )wxGridCellAttr_HasRenderer(_arg0);
3685
3686     wxPy_END_ALLOW_THREADS;
3687     if (PyErr_Occurred()) return NULL;
3688 }    _resultobj = Py_BuildValue("i",_result);
3689     return _resultobj;
3690 }
3691
3692 #define wxGridCellAttr_HasEditor(_swigobj)  (_swigobj->HasEditor())
3693 static PyObject *_wrap_wxGridCellAttr_HasEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3694     PyObject * _resultobj;
3695     bool  _result;
3696     wxGridCellAttr * _arg0;
3697     PyObject * _argo0 = 0;
3698     char *_kwnames[] = { "self", NULL };
3699
3700     self = self;
3701     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasEditor",_kwnames,&_argo0))
3702         return NULL;
3703     if (_argo0) {
3704         if (_argo0 == Py_None) { _arg0 = NULL; }
3705         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3706             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasEditor. Expected _wxGridCellAttr_p.");
3707         return NULL;
3708         }
3709     }
3710 {
3711     wxPy_BEGIN_ALLOW_THREADS;
3712         _result = (bool )wxGridCellAttr_HasEditor(_arg0);
3713
3714     wxPy_END_ALLOW_THREADS;
3715     if (PyErr_Occurred()) return NULL;
3716 }    _resultobj = Py_BuildValue("i",_result);
3717     return _resultobj;
3718 }
3719
3720 #define wxGridCellAttr_HasReadWriteMode(_swigobj)  (_swigobj->HasReadWriteMode())
3721 static PyObject *_wrap_wxGridCellAttr_HasReadWriteMode(PyObject *self, PyObject *args, PyObject *kwargs) {
3722     PyObject * _resultobj;
3723     bool  _result;
3724     wxGridCellAttr * _arg0;
3725     PyObject * _argo0 = 0;
3726     char *_kwnames[] = { "self", NULL };
3727
3728     self = self;
3729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasReadWriteMode",_kwnames,&_argo0))
3730         return NULL;
3731     if (_argo0) {
3732         if (_argo0 == Py_None) { _arg0 = NULL; }
3733         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3734             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasReadWriteMode. Expected _wxGridCellAttr_p.");
3735         return NULL;
3736         }
3737     }
3738 {
3739     wxPy_BEGIN_ALLOW_THREADS;
3740         _result = (bool )wxGridCellAttr_HasReadWriteMode(_arg0);
3741
3742     wxPy_END_ALLOW_THREADS;
3743     if (PyErr_Occurred()) return NULL;
3744 }    _resultobj = Py_BuildValue("i",_result);
3745     return _resultobj;
3746 }
3747
3748 #define wxGridCellAttr_GetTextColour(_swigobj)  (_swigobj->GetTextColour())
3749 static PyObject *_wrap_wxGridCellAttr_GetTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3750     PyObject * _resultobj;
3751     wxColour * _result;
3752     wxGridCellAttr * _arg0;
3753     PyObject * _argo0 = 0;
3754     char *_kwnames[] = { "self", NULL };
3755     char _ptemp[128];
3756
3757     self = self;
3758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetTextColour",_kwnames,&_argo0))
3759         return NULL;
3760     if (_argo0) {
3761         if (_argo0 == Py_None) { _arg0 = NULL; }
3762         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3763             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetTextColour. Expected _wxGridCellAttr_p.");
3764         return NULL;
3765         }
3766     }
3767 {
3768     wxPy_BEGIN_ALLOW_THREADS;
3769         _result = new wxColour (wxGridCellAttr_GetTextColour(_arg0));
3770
3771     wxPy_END_ALLOW_THREADS;
3772     if (PyErr_Occurred()) return NULL;
3773 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
3774     _resultobj = Py_BuildValue("s",_ptemp);
3775     return _resultobj;
3776 }
3777
3778 #define wxGridCellAttr_GetBackgroundColour(_swigobj)  (_swigobj->GetBackgroundColour())
3779 static PyObject *_wrap_wxGridCellAttr_GetBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3780     PyObject * _resultobj;
3781     wxColour * _result;
3782     wxGridCellAttr * _arg0;
3783     PyObject * _argo0 = 0;
3784     char *_kwnames[] = { "self", NULL };
3785     char _ptemp[128];
3786
3787     self = self;
3788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetBackgroundColour",_kwnames,&_argo0))
3789         return NULL;
3790     if (_argo0) {
3791         if (_argo0 == Py_None) { _arg0 = NULL; }
3792         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3793             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetBackgroundColour. Expected _wxGridCellAttr_p.");
3794         return NULL;
3795         }
3796     }
3797 {
3798     wxPy_BEGIN_ALLOW_THREADS;
3799         _result = new wxColour (wxGridCellAttr_GetBackgroundColour(_arg0));
3800
3801     wxPy_END_ALLOW_THREADS;
3802     if (PyErr_Occurred()) return NULL;
3803 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
3804     _resultobj = Py_BuildValue("s",_ptemp);
3805     return _resultobj;
3806 }
3807
3808 #define wxGridCellAttr_GetFont(_swigobj)  (_swigobj->GetFont())
3809 static PyObject *_wrap_wxGridCellAttr_GetFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3810     PyObject * _resultobj;
3811     wxFont * _result;
3812     wxGridCellAttr * _arg0;
3813     PyObject * _argo0 = 0;
3814     char *_kwnames[] = { "self", NULL };
3815     char _ptemp[128];
3816
3817     self = self;
3818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetFont",_kwnames,&_argo0))
3819         return NULL;
3820     if (_argo0) {
3821         if (_argo0 == Py_None) { _arg0 = NULL; }
3822         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3823             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetFont. Expected _wxGridCellAttr_p.");
3824         return NULL;
3825         }
3826     }
3827 {
3828     wxPy_BEGIN_ALLOW_THREADS;
3829         _result = new wxFont (wxGridCellAttr_GetFont(_arg0));
3830
3831     wxPy_END_ALLOW_THREADS;
3832     if (PyErr_Occurred()) return NULL;
3833 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
3834     _resultobj = Py_BuildValue("s",_ptemp);
3835     return _resultobj;
3836 }
3837
3838 #define wxGridCellAttr_GetAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetAlignment(_swigarg0,_swigarg1))
3839 static PyObject *_wrap_wxGridCellAttr_GetAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3840     PyObject * _resultobj;
3841     wxGridCellAttr * _arg0;
3842     int * _arg1;
3843     int  temp;
3844     int * _arg2;
3845     int  temp0;
3846     PyObject * _argo0 = 0;
3847     char *_kwnames[] = { "self", NULL };
3848
3849     self = self;
3850 {
3851   _arg1 = &temp;
3852 }
3853 {
3854   _arg2 = &temp0;
3855 }
3856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetAlignment",_kwnames,&_argo0))
3857         return NULL;
3858     if (_argo0) {
3859         if (_argo0 == Py_None) { _arg0 = NULL; }
3860         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3861             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetAlignment. Expected _wxGridCellAttr_p.");
3862         return NULL;
3863         }
3864     }
3865 {
3866     wxPy_BEGIN_ALLOW_THREADS;
3867         wxGridCellAttr_GetAlignment(_arg0,_arg1,_arg2);
3868
3869     wxPy_END_ALLOW_THREADS;
3870     if (PyErr_Occurred()) return NULL;
3871 }    Py_INCREF(Py_None);
3872     _resultobj = Py_None;
3873 {
3874     PyObject *o;
3875     o = PyInt_FromLong((long) (*_arg1));
3876     _resultobj = t_output_helper(_resultobj, o);
3877 }
3878 {
3879     PyObject *o;
3880     o = PyInt_FromLong((long) (*_arg2));
3881     _resultobj = t_output_helper(_resultobj, o);
3882 }
3883     return _resultobj;
3884 }
3885
3886 #define wxGridCellAttr_GetRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetRenderer(_swigarg0,_swigarg1,_swigarg2))
3887 static PyObject *_wrap_wxGridCellAttr_GetRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3888     PyObject * _resultobj;
3889     wxGridCellRenderer * _result;
3890     wxGridCellAttr * _arg0;
3891     wxGrid * _arg1;
3892     int  _arg2;
3893     int  _arg3;
3894     PyObject * _argo0 = 0;
3895     PyObject * _argo1 = 0;
3896     char *_kwnames[] = { "self","grid","row","col", NULL };
3897     char _ptemp[128];
3898
3899     self = self;
3900     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetRenderer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
3901         return NULL;
3902     if (_argo0) {
3903         if (_argo0 == Py_None) { _arg0 = NULL; }
3904         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3905             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetRenderer. Expected _wxGridCellAttr_p.");
3906         return NULL;
3907         }
3908     }
3909     if (_argo1) {
3910         if (_argo1 == Py_None) { _arg1 = NULL; }
3911         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
3912             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_GetRenderer. Expected _wxGrid_p.");
3913         return NULL;
3914         }
3915     }
3916 {
3917     wxPy_BEGIN_ALLOW_THREADS;
3918         _result = (wxGridCellRenderer *)wxGridCellAttr_GetRenderer(_arg0,_arg1,_arg2,_arg3);
3919
3920     wxPy_END_ALLOW_THREADS;
3921     if (PyErr_Occurred()) return NULL;
3922 }    if (_result) {
3923         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
3924         _resultobj = Py_BuildValue("s",_ptemp);
3925     } else {
3926         Py_INCREF(Py_None);
3927         _resultobj = Py_None;
3928     }
3929     return _resultobj;
3930 }
3931
3932 #define wxGridCellAttr_GetEditor(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetEditor(_swigarg0,_swigarg1,_swigarg2))
3933 static PyObject *_wrap_wxGridCellAttr_GetEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3934     PyObject * _resultobj;
3935     wxGridCellEditor * _result;
3936     wxGridCellAttr * _arg0;
3937     wxGrid * _arg1;
3938     int  _arg2;
3939     int  _arg3;
3940     PyObject * _argo0 = 0;
3941     PyObject * _argo1 = 0;
3942     char *_kwnames[] = { "self","grid","row","col", NULL };
3943     char _ptemp[128];
3944
3945     self = self;
3946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetEditor",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
3947         return NULL;
3948     if (_argo0) {
3949         if (_argo0 == Py_None) { _arg0 = NULL; }
3950         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3951             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetEditor. Expected _wxGridCellAttr_p.");
3952         return NULL;
3953         }
3954     }
3955     if (_argo1) {
3956         if (_argo1 == Py_None) { _arg1 = NULL; }
3957         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
3958             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_GetEditor. Expected _wxGrid_p.");
3959         return NULL;
3960         }
3961     }
3962 {
3963     wxPy_BEGIN_ALLOW_THREADS;
3964         _result = (wxGridCellEditor *)wxGridCellAttr_GetEditor(_arg0,_arg1,_arg2,_arg3);
3965
3966     wxPy_END_ALLOW_THREADS;
3967     if (PyErr_Occurred()) return NULL;
3968 }    if (_result) {
3969         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
3970         _resultobj = Py_BuildValue("s",_ptemp);
3971     } else {
3972         Py_INCREF(Py_None);
3973         _resultobj = Py_None;
3974     }
3975     return _resultobj;
3976 }
3977
3978 #define wxGridCellAttr_IsReadOnly(_swigobj)  (_swigobj->IsReadOnly())
3979 static PyObject *_wrap_wxGridCellAttr_IsReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
3980     PyObject * _resultobj;
3981     bool  _result;
3982     wxGridCellAttr * _arg0;
3983     PyObject * _argo0 = 0;
3984     char *_kwnames[] = { "self", NULL };
3985
3986     self = self;
3987     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_IsReadOnly",_kwnames,&_argo0))
3988         return NULL;
3989     if (_argo0) {
3990         if (_argo0 == Py_None) { _arg0 = NULL; }
3991         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3992             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_IsReadOnly. Expected _wxGridCellAttr_p.");
3993         return NULL;
3994         }
3995     }
3996 {
3997     wxPy_BEGIN_ALLOW_THREADS;
3998         _result = (bool )wxGridCellAttr_IsReadOnly(_arg0);
3999
4000     wxPy_END_ALLOW_THREADS;
4001     if (PyErr_Occurred()) return NULL;
4002 }    _resultobj = Py_BuildValue("i",_result);
4003     return _resultobj;
4004 }
4005
4006 #define wxGridCellAttr_SetDefAttr(_swigobj,_swigarg0)  (_swigobj->SetDefAttr(_swigarg0))
4007 static PyObject *_wrap_wxGridCellAttr_SetDefAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4008     PyObject * _resultobj;
4009     wxGridCellAttr * _arg0;
4010     wxGridCellAttr * _arg1;
4011     PyObject * _argo0 = 0;
4012     PyObject * _argo1 = 0;
4013     char *_kwnames[] = { "self","defAttr", NULL };
4014
4015     self = self;
4016     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetDefAttr",_kwnames,&_argo0,&_argo1))
4017         return NULL;
4018     if (_argo0) {
4019         if (_argo0 == Py_None) { _arg0 = NULL; }
4020         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
4021             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetDefAttr. Expected _wxGridCellAttr_p.");
4022         return NULL;
4023         }
4024     }
4025     if (_argo1) {
4026         if (_argo1 == Py_None) { _arg1 = NULL; }
4027         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4028             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetDefAttr. Expected _wxGridCellAttr_p.");
4029         return NULL;
4030         }
4031     }
4032 {
4033     wxPy_BEGIN_ALLOW_THREADS;
4034         wxGridCellAttr_SetDefAttr(_arg0,_arg1);
4035
4036     wxPy_END_ALLOW_THREADS;
4037     if (PyErr_Occurred()) return NULL;
4038 }    Py_INCREF(Py_None);
4039     _resultobj = Py_None;
4040     return _resultobj;
4041 }
4042
4043 #define new_wxGridCellAttrProvider() (new wxGridCellAttrProvider())
4044 static PyObject *_wrap_new_wxGridCellAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4045     PyObject * _resultobj;
4046     wxGridCellAttrProvider * _result;
4047     char *_kwnames[] = {  NULL };
4048     char _ptemp[128];
4049
4050     self = self;
4051     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttrProvider",_kwnames))
4052         return NULL;
4053 {
4054     wxPy_BEGIN_ALLOW_THREADS;
4055         _result = (wxGridCellAttrProvider *)new_wxGridCellAttrProvider();
4056
4057     wxPy_END_ALLOW_THREADS;
4058     if (PyErr_Occurred()) return NULL;
4059 }    if (_result) {
4060         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
4061         _resultobj = Py_BuildValue("s",_ptemp);
4062     } else {
4063         Py_INCREF(Py_None);
4064         _resultobj = Py_None;
4065     }
4066     return _resultobj;
4067 }
4068
4069 #define wxGridCellAttrProvider_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
4070 static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4071     PyObject * _resultobj;
4072     wxGridCellAttr * _result;
4073     wxGridCellAttrProvider * _arg0;
4074     int  _arg1;
4075     int  _arg2;
4076     wxGridCellAttr::wxAttrKind  _arg3;
4077     PyObject * _argo0 = 0;
4078     char *_kwnames[] = { "self","row","col","kind", NULL };
4079     char _ptemp[128];
4080
4081     self = self;
4082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridCellAttrProvider_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
4083         return NULL;
4084     if (_argo0) {
4085         if (_argo0 == Py_None) { _arg0 = NULL; }
4086         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4087             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_GetAttr. Expected _wxGridCellAttrProvider_p.");
4088         return NULL;
4089         }
4090     }
4091 {
4092     wxPy_BEGIN_ALLOW_THREADS;
4093         _result = (wxGridCellAttr *)wxGridCellAttrProvider_GetAttr(_arg0,_arg1,_arg2,_arg3);
4094
4095     wxPy_END_ALLOW_THREADS;
4096     if (PyErr_Occurred()) return NULL;
4097 }    if (_result) {
4098         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
4099         _resultobj = Py_BuildValue("s",_ptemp);
4100     } else {
4101         Py_INCREF(Py_None);
4102         _resultobj = Py_None;
4103     }
4104     return _resultobj;
4105 }
4106
4107 #define wxGridCellAttrProvider_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetAttr(_swigarg0,_swigarg1,_swigarg2))
4108 static PyObject *_wrap_wxGridCellAttrProvider_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4109     PyObject * _resultobj;
4110     wxGridCellAttrProvider * _arg0;
4111     wxGridCellAttr * _arg1;
4112     int  _arg2;
4113     int  _arg3;
4114     PyObject * _argo0 = 0;
4115     PyObject * _argo1 = 0;
4116     char *_kwnames[] = { "self","attr","row","col", NULL };
4117
4118     self = self;
4119     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttrProvider_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
4120         return NULL;
4121     if (_argo0) {
4122         if (_argo0 == Py_None) { _arg0 = NULL; }
4123         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4124             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetAttr. Expected _wxGridCellAttrProvider_p.");
4125         return NULL;
4126         }
4127     }
4128     if (_argo1) {
4129         if (_argo1 == Py_None) { _arg1 = NULL; }
4130         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4131             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetAttr. Expected _wxGridCellAttr_p.");
4132         return NULL;
4133         }
4134     }
4135 {
4136     wxPy_BEGIN_ALLOW_THREADS;
4137         wxGridCellAttrProvider_SetAttr(_arg0,_arg1,_arg2,_arg3);
4138
4139     wxPy_END_ALLOW_THREADS;
4140     if (PyErr_Occurred()) return NULL;
4141 }    Py_INCREF(Py_None);
4142     _resultobj = Py_None;
4143     return _resultobj;
4144 }
4145
4146 #define wxGridCellAttrProvider_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
4147 static PyObject *_wrap_wxGridCellAttrProvider_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4148     PyObject * _resultobj;
4149     wxGridCellAttrProvider * _arg0;
4150     wxGridCellAttr * _arg1;
4151     int  _arg2;
4152     PyObject * _argo0 = 0;
4153     PyObject * _argo1 = 0;
4154     char *_kwnames[] = { "self","attr","row", NULL };
4155
4156     self = self;
4157     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridCellAttrProvider_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4158         return NULL;
4159     if (_argo0) {
4160         if (_argo0 == Py_None) { _arg0 = NULL; }
4161         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4162             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetRowAttr. Expected _wxGridCellAttrProvider_p.");
4163         return NULL;
4164         }
4165     }
4166     if (_argo1) {
4167         if (_argo1 == Py_None) { _arg1 = NULL; }
4168         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4169             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetRowAttr. Expected _wxGridCellAttr_p.");
4170         return NULL;
4171         }
4172     }
4173 {
4174     wxPy_BEGIN_ALLOW_THREADS;
4175         wxGridCellAttrProvider_SetRowAttr(_arg0,_arg1,_arg2);
4176
4177     wxPy_END_ALLOW_THREADS;
4178     if (PyErr_Occurred()) return NULL;
4179 }    Py_INCREF(Py_None);
4180     _resultobj = Py_None;
4181     return _resultobj;
4182 }
4183
4184 #define wxGridCellAttrProvider_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
4185 static PyObject *_wrap_wxGridCellAttrProvider_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4186     PyObject * _resultobj;
4187     wxGridCellAttrProvider * _arg0;
4188     wxGridCellAttr * _arg1;
4189     int  _arg2;
4190     PyObject * _argo0 = 0;
4191     PyObject * _argo1 = 0;
4192     char *_kwnames[] = { "self","attr","col", NULL };
4193
4194     self = self;
4195     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridCellAttrProvider_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4196         return NULL;
4197     if (_argo0) {
4198         if (_argo0 == Py_None) { _arg0 = NULL; }
4199         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4200             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetColAttr. Expected _wxGridCellAttrProvider_p.");
4201         return NULL;
4202         }
4203     }
4204     if (_argo1) {
4205         if (_argo1 == Py_None) { _arg1 = NULL; }
4206         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4207             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetColAttr. Expected _wxGridCellAttr_p.");
4208         return NULL;
4209         }
4210     }
4211 {
4212     wxPy_BEGIN_ALLOW_THREADS;
4213         wxGridCellAttrProvider_SetColAttr(_arg0,_arg1,_arg2);
4214
4215     wxPy_END_ALLOW_THREADS;
4216     if (PyErr_Occurred()) return NULL;
4217 }    Py_INCREF(Py_None);
4218     _resultobj = Py_None;
4219     return _resultobj;
4220 }
4221
4222 #define wxGridCellAttrProvider_UpdateAttrRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->UpdateAttrRows(_swigarg0,_swigarg1))
4223 static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrRows(PyObject *self, PyObject *args, PyObject *kwargs) {
4224     PyObject * _resultobj;
4225     wxGridCellAttrProvider * _arg0;
4226     size_t  _arg1;
4227     int  _arg2;
4228     PyObject * _argo0 = 0;
4229     char *_kwnames[] = { "self","pos","numRows", NULL };
4230
4231     self = self;
4232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttrProvider_UpdateAttrRows",_kwnames,&_argo0,&_arg1,&_arg2))
4233         return NULL;
4234     if (_argo0) {
4235         if (_argo0 == Py_None) { _arg0 = NULL; }
4236         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4237             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_UpdateAttrRows. Expected _wxGridCellAttrProvider_p.");
4238         return NULL;
4239         }
4240     }
4241 {
4242     wxPy_BEGIN_ALLOW_THREADS;
4243         wxGridCellAttrProvider_UpdateAttrRows(_arg0,_arg1,_arg2);
4244
4245     wxPy_END_ALLOW_THREADS;
4246     if (PyErr_Occurred()) return NULL;
4247 }    Py_INCREF(Py_None);
4248     _resultobj = Py_None;
4249     return _resultobj;
4250 }
4251
4252 #define wxGridCellAttrProvider_UpdateAttrCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->UpdateAttrCols(_swigarg0,_swigarg1))
4253 static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrCols(PyObject *self, PyObject *args, PyObject *kwargs) {
4254     PyObject * _resultobj;
4255     wxGridCellAttrProvider * _arg0;
4256     size_t  _arg1;
4257     int  _arg2;
4258     PyObject * _argo0 = 0;
4259     char *_kwnames[] = { "self","pos","numCols", NULL };
4260
4261     self = self;
4262     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttrProvider_UpdateAttrCols",_kwnames,&_argo0,&_arg1,&_arg2))
4263         return NULL;
4264     if (_argo0) {
4265         if (_argo0 == Py_None) { _arg0 = NULL; }
4266         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4267             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_UpdateAttrCols. Expected _wxGridCellAttrProvider_p.");
4268         return NULL;
4269         }
4270     }
4271 {
4272     wxPy_BEGIN_ALLOW_THREADS;
4273         wxGridCellAttrProvider_UpdateAttrCols(_arg0,_arg1,_arg2);
4274
4275     wxPy_END_ALLOW_THREADS;
4276     if (PyErr_Occurred()) return NULL;
4277 }    Py_INCREF(Py_None);
4278     _resultobj = Py_None;
4279     return _resultobj;
4280 }
4281
4282 static void *SwigwxPyGridCellAttrProviderTowxGridCellAttrProvider(void *ptr) {
4283     wxPyGridCellAttrProvider *src;
4284     wxGridCellAttrProvider *dest;
4285     src = (wxPyGridCellAttrProvider *) ptr;
4286     dest = (wxGridCellAttrProvider *) src;
4287     return (void *) dest;
4288 }
4289
4290 #define new_wxPyGridCellAttrProvider() (new wxPyGridCellAttrProvider())
4291 static PyObject *_wrap_new_wxPyGridCellAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4292     PyObject * _resultobj;
4293     wxPyGridCellAttrProvider * _result;
4294     char *_kwnames[] = {  NULL };
4295     char _ptemp[128];
4296
4297     self = self;
4298     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellAttrProvider",_kwnames))
4299         return NULL;
4300 {
4301     wxPy_BEGIN_ALLOW_THREADS;
4302         _result = (wxPyGridCellAttrProvider *)new_wxPyGridCellAttrProvider();
4303
4304     wxPy_END_ALLOW_THREADS;
4305     if (PyErr_Occurred()) return NULL;
4306 }    if (_result) {
4307         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellAttrProvider_p");
4308         _resultobj = Py_BuildValue("s",_ptemp);
4309     } else {
4310         Py_INCREF(Py_None);
4311         _resultobj = Py_None;
4312     }
4313     return _resultobj;
4314 }
4315
4316 #define wxPyGridCellAttrProvider__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
4317 static PyObject *_wrap_wxPyGridCellAttrProvider__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
4318     PyObject * _resultobj;
4319     wxPyGridCellAttrProvider * _arg0;
4320     PyObject * _arg1;
4321     PyObject * _arg2;
4322     PyObject * _argo0 = 0;
4323     PyObject * _obj1 = 0;
4324     PyObject * _obj2 = 0;
4325     char *_kwnames[] = { "self","self","_class", NULL };
4326
4327     self = self;
4328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellAttrProvider__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
4329         return NULL;
4330     if (_argo0) {
4331         if (_argo0 == Py_None) { _arg0 = NULL; }
4332         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4333             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider__setCallbackInfo. Expected _wxPyGridCellAttrProvider_p.");
4334         return NULL;
4335         }
4336     }
4337 {
4338   _arg1 = _obj1;
4339 }
4340 {
4341   _arg2 = _obj2;
4342 }
4343 {
4344     wxPy_BEGIN_ALLOW_THREADS;
4345         wxPyGridCellAttrProvider__setCallbackInfo(_arg0,_arg1,_arg2);
4346
4347     wxPy_END_ALLOW_THREADS;
4348     if (PyErr_Occurred()) return NULL;
4349 }    Py_INCREF(Py_None);
4350     _resultobj = Py_None;
4351     return _resultobj;
4352 }
4353
4354 #define wxPyGridCellAttrProvider_base_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_GetAttr(_swigarg0,_swigarg1,_swigarg2))
4355 static PyObject *_wrap_wxPyGridCellAttrProvider_base_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4356     PyObject * _resultobj;
4357     wxGridCellAttr * _result;
4358     wxPyGridCellAttrProvider * _arg0;
4359     int  _arg1;
4360     int  _arg2;
4361     wxGridCellAttr::wxAttrKind  _arg3;
4362     PyObject * _argo0 = 0;
4363     char *_kwnames[] = { "self","row","col","kind", NULL };
4364     char _ptemp[128];
4365
4366     self = self;
4367     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridCellAttrProvider_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
4368         return NULL;
4369     if (_argo0) {
4370         if (_argo0 == Py_None) { _arg0 = NULL; }
4371         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4372             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_GetAttr. Expected _wxPyGridCellAttrProvider_p.");
4373         return NULL;
4374         }
4375     }
4376 {
4377     wxPy_BEGIN_ALLOW_THREADS;
4378         _result = (wxGridCellAttr *)wxPyGridCellAttrProvider_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
4379
4380     wxPy_END_ALLOW_THREADS;
4381     if (PyErr_Occurred()) return NULL;
4382 }    if (_result) {
4383         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
4384         _resultobj = Py_BuildValue("s",_ptemp);
4385     } else {
4386         Py_INCREF(Py_None);
4387         _resultobj = Py_None;
4388     }
4389     return _resultobj;
4390 }
4391
4392 #define wxPyGridCellAttrProvider_base_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_SetAttr(_swigarg0,_swigarg1,_swigarg2))
4393 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4394     PyObject * _resultobj;
4395     wxPyGridCellAttrProvider * _arg0;
4396     wxGridCellAttr * _arg1;
4397     int  _arg2;
4398     int  _arg3;
4399     PyObject * _argo0 = 0;
4400     PyObject * _argo1 = 0;
4401     char *_kwnames[] = { "self","attr","row","col", NULL };
4402
4403     self = self;
4404     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxPyGridCellAttrProvider_base_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
4405         return NULL;
4406     if (_argo0) {
4407         if (_argo0 == Py_None) { _arg0 = NULL; }
4408         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4409             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetAttr. Expected _wxPyGridCellAttrProvider_p.");
4410         return NULL;
4411         }
4412     }
4413     if (_argo1) {
4414         if (_argo1 == Py_None) { _arg1 = NULL; }
4415         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4416             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetAttr. Expected _wxGridCellAttr_p.");
4417         return NULL;
4418         }
4419     }
4420 {
4421     wxPy_BEGIN_ALLOW_THREADS;
4422         wxPyGridCellAttrProvider_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
4423
4424     wxPy_END_ALLOW_THREADS;
4425     if (PyErr_Occurred()) return NULL;
4426 }    Py_INCREF(Py_None);
4427     _resultobj = Py_None;
4428     return _resultobj;
4429 }
4430
4431 #define wxPyGridCellAttrProvider_base_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowAttr(_swigarg0,_swigarg1))
4432 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4433     PyObject * _resultobj;
4434     wxPyGridCellAttrProvider * _arg0;
4435     wxGridCellAttr * _arg1;
4436     int  _arg2;
4437     PyObject * _argo0 = 0;
4438     PyObject * _argo1 = 0;
4439     char *_kwnames[] = { "self","attr","row", NULL };
4440
4441     self = self;
4442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridCellAttrProvider_base_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4443         return NULL;
4444     if (_argo0) {
4445         if (_argo0 == Py_None) { _arg0 = NULL; }
4446         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4447             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetRowAttr. Expected _wxPyGridCellAttrProvider_p.");
4448         return NULL;
4449         }
4450     }
4451     if (_argo1) {
4452         if (_argo1 == Py_None) { _arg1 = NULL; }
4453         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4454             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetRowAttr. Expected _wxGridCellAttr_p.");
4455         return NULL;
4456         }
4457     }
4458 {
4459     wxPy_BEGIN_ALLOW_THREADS;
4460         wxPyGridCellAttrProvider_base_SetRowAttr(_arg0,_arg1,_arg2);
4461
4462     wxPy_END_ALLOW_THREADS;
4463     if (PyErr_Occurred()) return NULL;
4464 }    Py_INCREF(Py_None);
4465     _resultobj = Py_None;
4466     return _resultobj;
4467 }
4468
4469 #define wxPyGridCellAttrProvider_base_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColAttr(_swigarg0,_swigarg1))
4470 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4471     PyObject * _resultobj;
4472     wxPyGridCellAttrProvider * _arg0;
4473     wxGridCellAttr * _arg1;
4474     int  _arg2;
4475     PyObject * _argo0 = 0;
4476     PyObject * _argo1 = 0;
4477     char *_kwnames[] = { "self","attr","col", NULL };
4478
4479     self = self;
4480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridCellAttrProvider_base_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4481         return NULL;
4482     if (_argo0) {
4483         if (_argo0 == Py_None) { _arg0 = NULL; }
4484         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4485             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetColAttr. Expected _wxPyGridCellAttrProvider_p.");
4486         return NULL;
4487         }
4488     }
4489     if (_argo1) {
4490         if (_argo1 == Py_None) { _arg1 = NULL; }
4491         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4492             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetColAttr. Expected _wxGridCellAttr_p.");
4493         return NULL;
4494         }
4495     }
4496 {
4497     wxPy_BEGIN_ALLOW_THREADS;
4498         wxPyGridCellAttrProvider_base_SetColAttr(_arg0,_arg1,_arg2);
4499
4500     wxPy_END_ALLOW_THREADS;
4501     if (PyErr_Occurred()) return NULL;
4502 }    Py_INCREF(Py_None);
4503     _resultobj = Py_None;
4504     return _resultobj;
4505 }
4506
4507 static void *SwigwxGridTableBaseTowxObject(void *ptr) {
4508     wxGridTableBase *src;
4509     wxObject *dest;
4510     src = (wxGridTableBase *) ptr;
4511     dest = (wxObject *) src;
4512     return (void *) dest;
4513 }
4514
4515 #define wxGridTableBase_SetAttrProvider(_swigobj,_swigarg0)  (_swigobj->SetAttrProvider(_swigarg0))
4516 static PyObject *_wrap_wxGridTableBase_SetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4517     PyObject * _resultobj;
4518     wxGridTableBase * _arg0;
4519     wxGridCellAttrProvider * _arg1;
4520     PyObject * _argo0 = 0;
4521     PyObject * _argo1 = 0;
4522     char *_kwnames[] = { "self","attrProvider", NULL };
4523
4524     self = self;
4525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableBase_SetAttrProvider",_kwnames,&_argo0,&_argo1))
4526         return NULL;
4527     if (_argo0) {
4528         if (_argo0 == Py_None) { _arg0 = NULL; }
4529         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4530             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetAttrProvider. Expected _wxGridTableBase_p.");
4531         return NULL;
4532         }
4533     }
4534     if (_argo1) {
4535         if (_argo1 == Py_None) { _arg1 = NULL; }
4536         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttrProvider_p")) {
4537             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetAttrProvider. Expected _wxGridCellAttrProvider_p.");
4538         return NULL;
4539         }
4540     }
4541 {
4542     wxPy_BEGIN_ALLOW_THREADS;
4543         wxGridTableBase_SetAttrProvider(_arg0,_arg1);
4544
4545     wxPy_END_ALLOW_THREADS;
4546     if (PyErr_Occurred()) return NULL;
4547 }    Py_INCREF(Py_None);
4548     _resultobj = Py_None;
4549     return _resultobj;
4550 }
4551
4552 #define wxGridTableBase_GetAttrProvider(_swigobj)  (_swigobj->GetAttrProvider())
4553 static PyObject *_wrap_wxGridTableBase_GetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4554     PyObject * _resultobj;
4555     wxGridCellAttrProvider * _result;
4556     wxGridTableBase * _arg0;
4557     PyObject * _argo0 = 0;
4558     char *_kwnames[] = { "self", NULL };
4559     char _ptemp[128];
4560
4561     self = self;
4562     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetAttrProvider",_kwnames,&_argo0))
4563         return NULL;
4564     if (_argo0) {
4565         if (_argo0 == Py_None) { _arg0 = NULL; }
4566         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4567             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetAttrProvider. Expected _wxGridTableBase_p.");
4568         return NULL;
4569         }
4570     }
4571 {
4572     wxPy_BEGIN_ALLOW_THREADS;
4573         _result = (wxGridCellAttrProvider *)wxGridTableBase_GetAttrProvider(_arg0);
4574
4575     wxPy_END_ALLOW_THREADS;
4576     if (PyErr_Occurred()) return NULL;
4577 }    if (_result) {
4578         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
4579         _resultobj = Py_BuildValue("s",_ptemp);
4580     } else {
4581         Py_INCREF(Py_None);
4582         _resultobj = Py_None;
4583     }
4584     return _resultobj;
4585 }
4586
4587 #define wxGridTableBase_SetView(_swigobj,_swigarg0)  (_swigobj->SetView(_swigarg0))
4588 static PyObject *_wrap_wxGridTableBase_SetView(PyObject *self, PyObject *args, PyObject *kwargs) {
4589     PyObject * _resultobj;
4590     wxGridTableBase * _arg0;
4591     wxGrid * _arg1;
4592     PyObject * _argo0 = 0;
4593     PyObject * _argo1 = 0;
4594     char *_kwnames[] = { "self","grid", NULL };
4595
4596     self = self;
4597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableBase_SetView",_kwnames,&_argo0,&_argo1))
4598         return NULL;
4599     if (_argo0) {
4600         if (_argo0 == Py_None) { _arg0 = NULL; }
4601         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4602             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetView. Expected _wxGridTableBase_p.");
4603         return NULL;
4604         }
4605     }
4606     if (_argo1) {
4607         if (_argo1 == Py_None) { _arg1 = NULL; }
4608         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
4609             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetView. Expected _wxGrid_p.");
4610         return NULL;
4611         }
4612     }
4613 {
4614     wxPy_BEGIN_ALLOW_THREADS;
4615         wxGridTableBase_SetView(_arg0,_arg1);
4616
4617     wxPy_END_ALLOW_THREADS;
4618     if (PyErr_Occurred()) return NULL;
4619 }    Py_INCREF(Py_None);
4620     _resultobj = Py_None;
4621     return _resultobj;
4622 }
4623
4624 #define wxGridTableBase_GetView(_swigobj)  (_swigobj->GetView())
4625 static PyObject *_wrap_wxGridTableBase_GetView(PyObject *self, PyObject *args, PyObject *kwargs) {
4626     PyObject * _resultobj;
4627     wxGrid * _result;
4628     wxGridTableBase * _arg0;
4629     PyObject * _argo0 = 0;
4630     char *_kwnames[] = { "self", NULL };
4631
4632     self = self;
4633     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetView",_kwnames,&_argo0))
4634         return NULL;
4635     if (_argo0) {
4636         if (_argo0 == Py_None) { _arg0 = NULL; }
4637         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4638             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetView. Expected _wxGridTableBase_p.");
4639         return NULL;
4640         }
4641     }
4642 {
4643     wxPy_BEGIN_ALLOW_THREADS;
4644         _result = (wxGrid *)wxGridTableBase_GetView(_arg0);
4645
4646     wxPy_END_ALLOW_THREADS;
4647     if (PyErr_Occurred()) return NULL;
4648 }{ _resultobj = wxPyMake_wxObject(_result); }
4649     return _resultobj;
4650 }
4651
4652 #define wxGridTableBase_GetNumberRows(_swigobj)  (_swigobj->GetNumberRows())
4653 static PyObject *_wrap_wxGridTableBase_GetNumberRows(PyObject *self, PyObject *args, PyObject *kwargs) {
4654     PyObject * _resultobj;
4655     int  _result;
4656     wxGridTableBase * _arg0;
4657     PyObject * _argo0 = 0;
4658     char *_kwnames[] = { "self", NULL };
4659
4660     self = self;
4661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetNumberRows",_kwnames,&_argo0))
4662         return NULL;
4663     if (_argo0) {
4664         if (_argo0 == Py_None) { _arg0 = NULL; }
4665         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4666             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetNumberRows. Expected _wxGridTableBase_p.");
4667         return NULL;
4668         }
4669     }
4670 {
4671     wxPy_BEGIN_ALLOW_THREADS;
4672         _result = (int )wxGridTableBase_GetNumberRows(_arg0);
4673
4674     wxPy_END_ALLOW_THREADS;
4675     if (PyErr_Occurred()) return NULL;
4676 }    _resultobj = Py_BuildValue("i",_result);
4677     return _resultobj;
4678 }
4679
4680 #define wxGridTableBase_GetNumberCols(_swigobj)  (_swigobj->GetNumberCols())
4681 static PyObject *_wrap_wxGridTableBase_GetNumberCols(PyObject *self, PyObject *args, PyObject *kwargs) {
4682     PyObject * _resultobj;
4683     int  _result;
4684     wxGridTableBase * _arg0;
4685     PyObject * _argo0 = 0;
4686     char *_kwnames[] = { "self", NULL };
4687
4688     self = self;
4689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetNumberCols",_kwnames,&_argo0))
4690         return NULL;
4691     if (_argo0) {
4692         if (_argo0 == Py_None) { _arg0 = NULL; }
4693         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4694             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetNumberCols. Expected _wxGridTableBase_p.");
4695         return NULL;
4696         }
4697     }
4698 {
4699     wxPy_BEGIN_ALLOW_THREADS;
4700         _result = (int )wxGridTableBase_GetNumberCols(_arg0);
4701
4702     wxPy_END_ALLOW_THREADS;
4703     if (PyErr_Occurred()) return NULL;
4704 }    _resultobj = Py_BuildValue("i",_result);
4705     return _resultobj;
4706 }
4707
4708 #define wxGridTableBase_IsEmptyCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsEmptyCell(_swigarg0,_swigarg1))
4709 static PyObject *_wrap_wxGridTableBase_IsEmptyCell(PyObject *self, PyObject *args, PyObject *kwargs) {
4710     PyObject * _resultobj;
4711     bool  _result;
4712     wxGridTableBase * _arg0;
4713     int  _arg1;
4714     int  _arg2;
4715     PyObject * _argo0 = 0;
4716     char *_kwnames[] = { "self","row","col", NULL };
4717
4718     self = self;
4719     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_IsEmptyCell",_kwnames,&_argo0,&_arg1,&_arg2))
4720         return NULL;
4721     if (_argo0) {
4722         if (_argo0 == Py_None) { _arg0 = NULL; }
4723         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4724             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_IsEmptyCell. Expected _wxGridTableBase_p.");
4725         return NULL;
4726         }
4727     }
4728 {
4729     wxPy_BEGIN_ALLOW_THREADS;
4730         _result = (bool )wxGridTableBase_IsEmptyCell(_arg0,_arg1,_arg2);
4731
4732     wxPy_END_ALLOW_THREADS;
4733     if (PyErr_Occurred()) return NULL;
4734 }    _resultobj = Py_BuildValue("i",_result);
4735     return _resultobj;
4736 }
4737
4738 #define wxGridTableBase_GetValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValue(_swigarg0,_swigarg1))
4739 static PyObject *_wrap_wxGridTableBase_GetValue(PyObject *self, PyObject *args, PyObject *kwargs) {
4740     PyObject * _resultobj;
4741     wxString * _result;
4742     wxGridTableBase * _arg0;
4743     int  _arg1;
4744     int  _arg2;
4745     PyObject * _argo0 = 0;
4746     char *_kwnames[] = { "self","row","col", NULL };
4747
4748     self = self;
4749     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValue",_kwnames,&_argo0,&_arg1,&_arg2))
4750         return NULL;
4751     if (_argo0) {
4752         if (_argo0 == Py_None) { _arg0 = NULL; }
4753         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4754             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValue. Expected _wxGridTableBase_p.");
4755         return NULL;
4756         }
4757     }
4758 {
4759     wxPy_BEGIN_ALLOW_THREADS;
4760         _result = new wxString (wxGridTableBase_GetValue(_arg0,_arg1,_arg2));
4761
4762     wxPy_END_ALLOW_THREADS;
4763     if (PyErr_Occurred()) return NULL;
4764 }{
4765     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
4766 }
4767 {
4768     delete _result;
4769 }
4770     return _resultobj;
4771 }
4772
4773 #define wxGridTableBase_SetValue(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValue(_swigarg0,_swigarg1,_swigarg2))
4774 static PyObject *_wrap_wxGridTableBase_SetValue(PyObject *self, PyObject *args, PyObject *kwargs) {
4775     PyObject * _resultobj;
4776     wxGridTableBase * _arg0;
4777     int  _arg1;
4778     int  _arg2;
4779     wxString * _arg3;
4780     PyObject * _argo0 = 0;
4781     PyObject * _obj3 = 0;
4782     char *_kwnames[] = { "self","row","col","value", NULL };
4783
4784     self = self;
4785     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_SetValue",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4786         return NULL;
4787     if (_argo0) {
4788         if (_argo0 == Py_None) { _arg0 = NULL; }
4789         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4790             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValue. Expected _wxGridTableBase_p.");
4791         return NULL;
4792         }
4793     }
4794 {
4795 #if PYTHON_API_VERSION >= 1009
4796     char* tmpPtr; int tmpSize;
4797     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4798         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4799         return NULL;
4800     }
4801     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4802         return NULL;
4803     _arg3 = new wxString(tmpPtr, tmpSize);
4804 #else
4805     if (!PyString_Check(_obj3)) {
4806         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4807         return NULL;
4808     }
4809     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4810 #endif
4811 }
4812 {
4813     wxPy_BEGIN_ALLOW_THREADS;
4814         wxGridTableBase_SetValue(_arg0,_arg1,_arg2,*_arg3);
4815
4816     wxPy_END_ALLOW_THREADS;
4817     if (PyErr_Occurred()) return NULL;
4818 }    Py_INCREF(Py_None);
4819     _resultobj = Py_None;
4820 {
4821     if (_obj3)
4822         delete _arg3;
4823 }
4824     return _resultobj;
4825 }
4826
4827 #define wxGridTableBase_GetTypeName(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetTypeName(_swigarg0,_swigarg1))
4828 static PyObject *_wrap_wxGridTableBase_GetTypeName(PyObject *self, PyObject *args, PyObject *kwargs) {
4829     PyObject * _resultobj;
4830     wxString * _result;
4831     wxGridTableBase * _arg0;
4832     int  _arg1;
4833     int  _arg2;
4834     PyObject * _argo0 = 0;
4835     char *_kwnames[] = { "self","row","col", NULL };
4836
4837     self = self;
4838     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetTypeName",_kwnames,&_argo0,&_arg1,&_arg2))
4839         return NULL;
4840     if (_argo0) {
4841         if (_argo0 == Py_None) { _arg0 = NULL; }
4842         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4843             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetTypeName. Expected _wxGridTableBase_p.");
4844         return NULL;
4845         }
4846     }
4847 {
4848     wxPy_BEGIN_ALLOW_THREADS;
4849         _result = new wxString (wxGridTableBase_GetTypeName(_arg0,_arg1,_arg2));
4850
4851     wxPy_END_ALLOW_THREADS;
4852     if (PyErr_Occurred()) return NULL;
4853 }{
4854     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
4855 }
4856 {
4857     delete _result;
4858 }
4859     return _resultobj;
4860 }
4861
4862 #define wxGridTableBase_CanGetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CanGetValueAs(_swigarg0,_swigarg1,_swigarg2))
4863 static PyObject *_wrap_wxGridTableBase_CanGetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
4864     PyObject * _resultobj;
4865     bool  _result;
4866     wxGridTableBase * _arg0;
4867     int  _arg1;
4868     int  _arg2;
4869     wxString * _arg3;
4870     PyObject * _argo0 = 0;
4871     PyObject * _obj3 = 0;
4872     char *_kwnames[] = { "self","row","col","typeName", NULL };
4873
4874     self = self;
4875     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_CanGetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4876         return NULL;
4877     if (_argo0) {
4878         if (_argo0 == Py_None) { _arg0 = NULL; }
4879         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4880             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanGetValueAs. Expected _wxGridTableBase_p.");
4881         return NULL;
4882         }
4883     }
4884 {
4885 #if PYTHON_API_VERSION >= 1009
4886     char* tmpPtr; int tmpSize;
4887     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4888         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4889         return NULL;
4890     }
4891     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4892         return NULL;
4893     _arg3 = new wxString(tmpPtr, tmpSize);
4894 #else
4895     if (!PyString_Check(_obj3)) {
4896         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4897         return NULL;
4898     }
4899     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4900 #endif
4901 }
4902 {
4903     wxPy_BEGIN_ALLOW_THREADS;
4904         _result = (bool )wxGridTableBase_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
4905
4906     wxPy_END_ALLOW_THREADS;
4907     if (PyErr_Occurred()) return NULL;
4908 }    _resultobj = Py_BuildValue("i",_result);
4909 {
4910     if (_obj3)
4911         delete _arg3;
4912 }
4913     return _resultobj;
4914 }
4915
4916 #define wxGridTableBase_CanSetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CanSetValueAs(_swigarg0,_swigarg1,_swigarg2))
4917 static PyObject *_wrap_wxGridTableBase_CanSetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
4918     PyObject * _resultobj;
4919     bool  _result;
4920     wxGridTableBase * _arg0;
4921     int  _arg1;
4922     int  _arg2;
4923     wxString * _arg3;
4924     PyObject * _argo0 = 0;
4925     PyObject * _obj3 = 0;
4926     char *_kwnames[] = { "self","row","col","typeName", NULL };
4927
4928     self = self;
4929     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_CanSetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4930         return NULL;
4931     if (_argo0) {
4932         if (_argo0 == Py_None) { _arg0 = NULL; }
4933         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4934             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanSetValueAs. Expected _wxGridTableBase_p.");
4935         return NULL;
4936         }
4937     }
4938 {
4939 #if PYTHON_API_VERSION >= 1009
4940     char* tmpPtr; int tmpSize;
4941     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4942         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4943         return NULL;
4944     }
4945     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4946         return NULL;
4947     _arg3 = new wxString(tmpPtr, tmpSize);
4948 #else
4949     if (!PyString_Check(_obj3)) {
4950         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4951         return NULL;
4952     }
4953     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4954 #endif
4955 }
4956 {
4957     wxPy_BEGIN_ALLOW_THREADS;
4958         _result = (bool )wxGridTableBase_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
4959
4960     wxPy_END_ALLOW_THREADS;
4961     if (PyErr_Occurred()) return NULL;
4962 }    _resultobj = Py_BuildValue("i",_result);
4963 {
4964     if (_obj3)
4965         delete _arg3;
4966 }
4967     return _resultobj;
4968 }
4969
4970 #define wxGridTableBase_GetValueAsLong(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsLong(_swigarg0,_swigarg1))
4971 static PyObject *_wrap_wxGridTableBase_GetValueAsLong(PyObject *self, PyObject *args, PyObject *kwargs) {
4972     PyObject * _resultobj;
4973     long  _result;
4974     wxGridTableBase * _arg0;
4975     int  _arg1;
4976     int  _arg2;
4977     PyObject * _argo0 = 0;
4978     char *_kwnames[] = { "self","row","col", NULL };
4979
4980     self = self;
4981     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsLong",_kwnames,&_argo0,&_arg1,&_arg2))
4982         return NULL;
4983     if (_argo0) {
4984         if (_argo0 == Py_None) { _arg0 = NULL; }
4985         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4986             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsLong. Expected _wxGridTableBase_p.");
4987         return NULL;
4988         }
4989     }
4990 {
4991     wxPy_BEGIN_ALLOW_THREADS;
4992         _result = (long )wxGridTableBase_GetValueAsLong(_arg0,_arg1,_arg2);
4993
4994     wxPy_END_ALLOW_THREADS;
4995     if (PyErr_Occurred()) return NULL;
4996 }    _resultobj = Py_BuildValue("l",_result);
4997     return _resultobj;
4998 }
4999
5000 #define wxGridTableBase_GetValueAsDouble(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsDouble(_swigarg0,_swigarg1))
5001 static PyObject *_wrap_wxGridTableBase_GetValueAsDouble(PyObject *self, PyObject *args, PyObject *kwargs) {
5002     PyObject * _resultobj;
5003     double  _result;
5004     wxGridTableBase * _arg0;
5005     int  _arg1;
5006     int  _arg2;
5007     PyObject * _argo0 = 0;
5008     char *_kwnames[] = { "self","row","col", NULL };
5009
5010     self = self;
5011     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsDouble",_kwnames,&_argo0,&_arg1,&_arg2))
5012         return NULL;
5013     if (_argo0) {
5014         if (_argo0 == Py_None) { _arg0 = NULL; }
5015         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5016             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsDouble. Expected _wxGridTableBase_p.");
5017         return NULL;
5018         }
5019     }
5020 {
5021     wxPy_BEGIN_ALLOW_THREADS;
5022         _result = (double )wxGridTableBase_GetValueAsDouble(_arg0,_arg1,_arg2);
5023
5024     wxPy_END_ALLOW_THREADS;
5025     if (PyErr_Occurred()) return NULL;
5026 }    _resultobj = Py_BuildValue("d",_result);
5027     return _resultobj;
5028 }
5029
5030 #define wxGridTableBase_GetValueAsBool(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsBool(_swigarg0,_swigarg1))
5031 static PyObject *_wrap_wxGridTableBase_GetValueAsBool(PyObject *self, PyObject *args, PyObject *kwargs) {
5032     PyObject * _resultobj;
5033     bool  _result;
5034     wxGridTableBase * _arg0;
5035     int  _arg1;
5036     int  _arg2;
5037     PyObject * _argo0 = 0;
5038     char *_kwnames[] = { "self","row","col", NULL };
5039
5040     self = self;
5041     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsBool",_kwnames,&_argo0,&_arg1,&_arg2))
5042         return NULL;
5043     if (_argo0) {
5044         if (_argo0 == Py_None) { _arg0 = NULL; }
5045         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5046             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsBool. Expected _wxGridTableBase_p.");
5047         return NULL;
5048         }
5049     }
5050 {
5051     wxPy_BEGIN_ALLOW_THREADS;
5052         _result = (bool )wxGridTableBase_GetValueAsBool(_arg0,_arg1,_arg2);
5053
5054     wxPy_END_ALLOW_THREADS;
5055     if (PyErr_Occurred()) return NULL;
5056 }    _resultobj = Py_BuildValue("i",_result);
5057     return _resultobj;
5058 }
5059
5060 #define wxGridTableBase_SetValueAsLong(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsLong(_swigarg0,_swigarg1,_swigarg2))
5061 static PyObject *_wrap_wxGridTableBase_SetValueAsLong(PyObject *self, PyObject *args, PyObject *kwargs) {
5062     PyObject * _resultobj;
5063     wxGridTableBase * _arg0;
5064     int  _arg1;
5065     int  _arg2;
5066     long  _arg3;
5067     PyObject * _argo0 = 0;
5068     char *_kwnames[] = { "self","row","col","value", NULL };
5069
5070     self = self;
5071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiil:wxGridTableBase_SetValueAsLong",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5072         return NULL;
5073     if (_argo0) {
5074         if (_argo0 == Py_None) { _arg0 = NULL; }
5075         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5076             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsLong. Expected _wxGridTableBase_p.");
5077         return NULL;
5078         }
5079     }
5080 {
5081     wxPy_BEGIN_ALLOW_THREADS;
5082         wxGridTableBase_SetValueAsLong(_arg0,_arg1,_arg2,_arg3);
5083
5084     wxPy_END_ALLOW_THREADS;
5085     if (PyErr_Occurred()) return NULL;
5086 }    Py_INCREF(Py_None);
5087     _resultobj = Py_None;
5088     return _resultobj;
5089 }
5090
5091 #define wxGridTableBase_SetValueAsDouble(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsDouble(_swigarg0,_swigarg1,_swigarg2))
5092 static PyObject *_wrap_wxGridTableBase_SetValueAsDouble(PyObject *self, PyObject *args, PyObject *kwargs) {
5093     PyObject * _resultobj;
5094     wxGridTableBase * _arg0;
5095     int  _arg1;
5096     int  _arg2;
5097     double  _arg3;
5098     PyObject * _argo0 = 0;
5099     char *_kwnames[] = { "self","row","col","value", NULL };
5100
5101     self = self;
5102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiid:wxGridTableBase_SetValueAsDouble",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5103         return NULL;
5104     if (_argo0) {
5105         if (_argo0 == Py_None) { _arg0 = NULL; }
5106         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5107             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsDouble. Expected _wxGridTableBase_p.");
5108         return NULL;
5109         }
5110     }
5111 {
5112     wxPy_BEGIN_ALLOW_THREADS;
5113         wxGridTableBase_SetValueAsDouble(_arg0,_arg1,_arg2,_arg3);
5114
5115     wxPy_END_ALLOW_THREADS;
5116     if (PyErr_Occurred()) return NULL;
5117 }    Py_INCREF(Py_None);
5118     _resultobj = Py_None;
5119     return _resultobj;
5120 }
5121
5122 #define wxGridTableBase_SetValueAsBool(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsBool(_swigarg0,_swigarg1,_swigarg2))
5123 static PyObject *_wrap_wxGridTableBase_SetValueAsBool(PyObject *self, PyObject *args, PyObject *kwargs) {
5124     PyObject * _resultobj;
5125     wxGridTableBase * _arg0;
5126     int  _arg1;
5127     int  _arg2;
5128     bool  _arg3;
5129     PyObject * _argo0 = 0;
5130     int tempbool3;
5131     char *_kwnames[] = { "self","row","col","value", NULL };
5132
5133     self = self;
5134     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_SetValueAsBool",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
5135         return NULL;
5136     if (_argo0) {
5137         if (_argo0 == Py_None) { _arg0 = NULL; }
5138         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5139             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsBool. Expected _wxGridTableBase_p.");
5140         return NULL;
5141         }
5142     }
5143     _arg3 = (bool ) tempbool3;
5144 {
5145     wxPy_BEGIN_ALLOW_THREADS;
5146         wxGridTableBase_SetValueAsBool(_arg0,_arg1,_arg2,_arg3);
5147
5148     wxPy_END_ALLOW_THREADS;
5149     if (PyErr_Occurred()) return NULL;
5150 }    Py_INCREF(Py_None);
5151     _resultobj = Py_None;
5152     return _resultobj;
5153 }
5154
5155 #define wxGridTableBase_Clear(_swigobj)  (_swigobj->Clear())
5156 static PyObject *_wrap_wxGridTableBase_Clear(PyObject *self, PyObject *args, PyObject *kwargs) {
5157     PyObject * _resultobj;
5158     wxGridTableBase * _arg0;
5159     PyObject * _argo0 = 0;
5160     char *_kwnames[] = { "self", NULL };
5161
5162     self = self;
5163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_Clear",_kwnames,&_argo0))
5164         return NULL;
5165     if (_argo0) {
5166         if (_argo0 == Py_None) { _arg0 = NULL; }
5167         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5168             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_Clear. Expected _wxGridTableBase_p.");
5169         return NULL;
5170         }
5171     }
5172 {
5173     wxPy_BEGIN_ALLOW_THREADS;
5174         wxGridTableBase_Clear(_arg0);
5175
5176     wxPy_END_ALLOW_THREADS;
5177     if (PyErr_Occurred()) return NULL;
5178 }    Py_INCREF(Py_None);
5179     _resultobj = Py_None;
5180     return _resultobj;
5181 }
5182
5183 #define wxGridTableBase_InsertRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->InsertRows(_swigarg0,_swigarg1))
5184 static PyObject *_wrap_wxGridTableBase_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5185     PyObject * _resultobj;
5186     bool  _result;
5187     wxGridTableBase * _arg0;
5188     size_t  _arg1 = (size_t ) 0;
5189     size_t  _arg2 = (size_t ) 1;
5190     PyObject * _argo0 = 0;
5191     char *_kwnames[] = { "self","pos","numRows", NULL };
5192
5193     self = self;
5194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2))
5195         return NULL;
5196     if (_argo0) {
5197         if (_argo0 == Py_None) { _arg0 = NULL; }
5198         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5199             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_InsertRows. Expected _wxGridTableBase_p.");
5200         return NULL;
5201         }
5202     }
5203 {
5204     wxPy_BEGIN_ALLOW_THREADS;
5205         _result = (bool )wxGridTableBase_InsertRows(_arg0,_arg1,_arg2);
5206
5207     wxPy_END_ALLOW_THREADS;
5208     if (PyErr_Occurred()) return NULL;
5209 }    _resultobj = Py_BuildValue("i",_result);
5210     return _resultobj;
5211 }
5212
5213 #define wxGridTableBase_AppendRows(_swigobj,_swigarg0)  (_swigobj->AppendRows(_swigarg0))
5214 static PyObject *_wrap_wxGridTableBase_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5215     PyObject * _resultobj;
5216     bool  _result;
5217     wxGridTableBase * _arg0;
5218     size_t  _arg1 = (size_t ) 1;
5219     PyObject * _argo0 = 0;
5220     char *_kwnames[] = { "self","numRows", NULL };
5221
5222     self = self;
5223     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridTableBase_AppendRows",_kwnames,&_argo0,&_arg1))
5224         return NULL;
5225     if (_argo0) {
5226         if (_argo0 == Py_None) { _arg0 = NULL; }
5227         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5228             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_AppendRows. Expected _wxGridTableBase_p.");
5229         return NULL;
5230         }
5231     }
5232 {
5233     wxPy_BEGIN_ALLOW_THREADS;
5234         _result = (bool )wxGridTableBase_AppendRows(_arg0,_arg1);
5235
5236     wxPy_END_ALLOW_THREADS;
5237     if (PyErr_Occurred()) return NULL;
5238 }    _resultobj = Py_BuildValue("i",_result);
5239     return _resultobj;
5240 }
5241
5242 #define wxGridTableBase_DeleteRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DeleteRows(_swigarg0,_swigarg1))
5243 static PyObject *_wrap_wxGridTableBase_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5244     PyObject * _resultobj;
5245     bool  _result;
5246     wxGridTableBase * _arg0;
5247     size_t  _arg1 = (size_t ) 0;
5248     size_t  _arg2 = (size_t ) 1;
5249     PyObject * _argo0 = 0;
5250     char *_kwnames[] = { "self","pos","numRows", NULL };
5251
5252     self = self;
5253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2))
5254         return NULL;
5255     if (_argo0) {
5256         if (_argo0 == Py_None) { _arg0 = NULL; }
5257         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5258             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_DeleteRows. Expected _wxGridTableBase_p.");
5259         return NULL;
5260         }
5261     }
5262 {
5263     wxPy_BEGIN_ALLOW_THREADS;
5264         _result = (bool )wxGridTableBase_DeleteRows(_arg0,_arg1,_arg2);
5265
5266     wxPy_END_ALLOW_THREADS;
5267     if (PyErr_Occurred()) return NULL;
5268 }    _resultobj = Py_BuildValue("i",_result);
5269     return _resultobj;
5270 }
5271
5272 #define wxGridTableBase_InsertCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->InsertCols(_swigarg0,_swigarg1))
5273 static PyObject *_wrap_wxGridTableBase_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5274     PyObject * _resultobj;
5275     bool  _result;
5276     wxGridTableBase * _arg0;
5277     size_t  _arg1 = (size_t ) 0;
5278     size_t  _arg2 = (size_t ) 1;
5279     PyObject * _argo0 = 0;
5280     char *_kwnames[] = { "self","pos","numCols", NULL };
5281
5282     self = self;
5283     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2))
5284         return NULL;
5285     if (_argo0) {
5286         if (_argo0 == Py_None) { _arg0 = NULL; }
5287         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5288             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_InsertCols. Expected _wxGridTableBase_p.");
5289         return NULL;
5290         }
5291     }
5292 {
5293     wxPy_BEGIN_ALLOW_THREADS;
5294         _result = (bool )wxGridTableBase_InsertCols(_arg0,_arg1,_arg2);
5295
5296     wxPy_END_ALLOW_THREADS;
5297     if (PyErr_Occurred()) return NULL;
5298 }    _resultobj = Py_BuildValue("i",_result);
5299     return _resultobj;
5300 }
5301
5302 #define wxGridTableBase_AppendCols(_swigobj,_swigarg0)  (_swigobj->AppendCols(_swigarg0))
5303 static PyObject *_wrap_wxGridTableBase_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5304     PyObject * _resultobj;
5305     bool  _result;
5306     wxGridTableBase * _arg0;
5307     size_t  _arg1 = (size_t ) 1;
5308     PyObject * _argo0 = 0;
5309     char *_kwnames[] = { "self","numCols", NULL };
5310
5311     self = self;
5312     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridTableBase_AppendCols",_kwnames,&_argo0,&_arg1))
5313         return NULL;
5314     if (_argo0) {
5315         if (_argo0 == Py_None) { _arg0 = NULL; }
5316         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5317             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_AppendCols. Expected _wxGridTableBase_p.");
5318         return NULL;
5319         }
5320     }
5321 {
5322     wxPy_BEGIN_ALLOW_THREADS;
5323         _result = (bool )wxGridTableBase_AppendCols(_arg0,_arg1);
5324
5325     wxPy_END_ALLOW_THREADS;
5326     if (PyErr_Occurred()) return NULL;
5327 }    _resultobj = Py_BuildValue("i",_result);
5328     return _resultobj;
5329 }
5330
5331 #define wxGridTableBase_DeleteCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DeleteCols(_swigarg0,_swigarg1))
5332 static PyObject *_wrap_wxGridTableBase_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5333     PyObject * _resultobj;
5334     bool  _result;
5335     wxGridTableBase * _arg0;
5336     size_t  _arg1 = (size_t ) 0;
5337     size_t  _arg2 = (size_t ) 1;
5338     PyObject * _argo0 = 0;
5339     char *_kwnames[] = { "self","pos","numCols", NULL };
5340
5341     self = self;
5342     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2))
5343         return NULL;
5344     if (_argo0) {
5345         if (_argo0 == Py_None) { _arg0 = NULL; }
5346         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5347             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_DeleteCols. Expected _wxGridTableBase_p.");
5348         return NULL;
5349         }
5350     }
5351 {
5352     wxPy_BEGIN_ALLOW_THREADS;
5353         _result = (bool )wxGridTableBase_DeleteCols(_arg0,_arg1,_arg2);
5354
5355     wxPy_END_ALLOW_THREADS;
5356     if (PyErr_Occurred()) return NULL;
5357 }    _resultobj = Py_BuildValue("i",_result);
5358     return _resultobj;
5359 }
5360
5361 #define wxGridTableBase_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->GetRowLabelValue(_swigarg0))
5362 static PyObject *_wrap_wxGridTableBase_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5363     PyObject * _resultobj;
5364     wxString * _result;
5365     wxGridTableBase * _arg0;
5366     int  _arg1;
5367     PyObject * _argo0 = 0;
5368     char *_kwnames[] = { "self","row", NULL };
5369
5370     self = self;
5371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableBase_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
5372         return NULL;
5373     if (_argo0) {
5374         if (_argo0 == Py_None) { _arg0 = NULL; }
5375         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5376             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetRowLabelValue. Expected _wxGridTableBase_p.");
5377         return NULL;
5378         }
5379     }
5380 {
5381     wxPy_BEGIN_ALLOW_THREADS;
5382         _result = new wxString (wxGridTableBase_GetRowLabelValue(_arg0,_arg1));
5383
5384     wxPy_END_ALLOW_THREADS;
5385     if (PyErr_Occurred()) return NULL;
5386 }{
5387     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5388 }
5389 {
5390     delete _result;
5391 }
5392     return _resultobj;
5393 }
5394
5395 #define wxGridTableBase_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->GetColLabelValue(_swigarg0))
5396 static PyObject *_wrap_wxGridTableBase_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5397     PyObject * _resultobj;
5398     wxString * _result;
5399     wxGridTableBase * _arg0;
5400     int  _arg1;
5401     PyObject * _argo0 = 0;
5402     char *_kwnames[] = { "self","col", NULL };
5403
5404     self = self;
5405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableBase_GetColLabelValue",_kwnames,&_argo0,&_arg1))
5406         return NULL;
5407     if (_argo0) {
5408         if (_argo0 == Py_None) { _arg0 = NULL; }
5409         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5410             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetColLabelValue. Expected _wxGridTableBase_p.");
5411         return NULL;
5412         }
5413     }
5414 {
5415     wxPy_BEGIN_ALLOW_THREADS;
5416         _result = new wxString (wxGridTableBase_GetColLabelValue(_arg0,_arg1));
5417
5418     wxPy_END_ALLOW_THREADS;
5419     if (PyErr_Occurred()) return NULL;
5420 }{
5421     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5422 }
5423 {
5424     delete _result;
5425 }
5426     return _resultobj;
5427 }
5428
5429 #define wxGridTableBase_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelValue(_swigarg0,_swigarg1))
5430 static PyObject *_wrap_wxGridTableBase_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5431     PyObject * _resultobj;
5432     wxGridTableBase * _arg0;
5433     int  _arg1;
5434     wxString * _arg2;
5435     PyObject * _argo0 = 0;
5436     PyObject * _obj2 = 0;
5437     char *_kwnames[] = { "self","row","value", NULL };
5438
5439     self = self;
5440     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGridTableBase_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
5441         return NULL;
5442     if (_argo0) {
5443         if (_argo0 == Py_None) { _arg0 = NULL; }
5444         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5445             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetRowLabelValue. Expected _wxGridTableBase_p.");
5446         return NULL;
5447         }
5448     }
5449 {
5450 #if PYTHON_API_VERSION >= 1009
5451     char* tmpPtr; int tmpSize;
5452     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
5453         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5454         return NULL;
5455     }
5456     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
5457         return NULL;
5458     _arg2 = new wxString(tmpPtr, tmpSize);
5459 #else
5460     if (!PyString_Check(_obj2)) {
5461         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5462         return NULL;
5463     }
5464     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
5465 #endif
5466 }
5467 {
5468     wxPy_BEGIN_ALLOW_THREADS;
5469         wxGridTableBase_SetRowLabelValue(_arg0,_arg1,*_arg2);
5470
5471     wxPy_END_ALLOW_THREADS;
5472     if (PyErr_Occurred()) return NULL;
5473 }    Py_INCREF(Py_None);
5474     _resultobj = Py_None;
5475 {
5476     if (_obj2)
5477         delete _arg2;
5478 }
5479     return _resultobj;
5480 }
5481
5482 #define wxGridTableBase_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelValue(_swigarg0,_swigarg1))
5483 static PyObject *_wrap_wxGridTableBase_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5484     PyObject * _resultobj;
5485     wxGridTableBase * _arg0;
5486     int  _arg1;
5487     wxString * _arg2;
5488     PyObject * _argo0 = 0;
5489     PyObject * _obj2 = 0;
5490     char *_kwnames[] = { "self","col","value", NULL };
5491
5492     self = self;
5493     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGridTableBase_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
5494         return NULL;
5495     if (_argo0) {
5496         if (_argo0 == Py_None) { _arg0 = NULL; }
5497         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5498             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetColLabelValue. Expected _wxGridTableBase_p.");
5499         return NULL;
5500         }
5501     }
5502 {
5503 #if PYTHON_API_VERSION >= 1009
5504     char* tmpPtr; int tmpSize;
5505     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
5506         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5507         return NULL;
5508     }
5509     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
5510         return NULL;
5511     _arg2 = new wxString(tmpPtr, tmpSize);
5512 #else
5513     if (!PyString_Check(_obj2)) {
5514         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5515         return NULL;
5516     }
5517     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
5518 #endif
5519 }
5520 {
5521     wxPy_BEGIN_ALLOW_THREADS;
5522         wxGridTableBase_SetColLabelValue(_arg0,_arg1,*_arg2);
5523
5524     wxPy_END_ALLOW_THREADS;
5525     if (PyErr_Occurred()) return NULL;
5526 }    Py_INCREF(Py_None);
5527     _resultobj = Py_None;
5528 {
5529     if (_obj2)
5530         delete _arg2;
5531 }
5532     return _resultobj;
5533 }
5534
5535 #define wxGridTableBase_CanHaveAttributes(_swigobj)  (_swigobj->CanHaveAttributes())
5536 static PyObject *_wrap_wxGridTableBase_CanHaveAttributes(PyObject *self, PyObject *args, PyObject *kwargs) {
5537     PyObject * _resultobj;
5538     bool  _result;
5539     wxGridTableBase * _arg0;
5540     PyObject * _argo0 = 0;
5541     char *_kwnames[] = { "self", NULL };
5542
5543     self = self;
5544     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_CanHaveAttributes",_kwnames,&_argo0))
5545         return NULL;
5546     if (_argo0) {
5547         if (_argo0 == Py_None) { _arg0 = NULL; }
5548         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5549             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanHaveAttributes. Expected _wxGridTableBase_p.");
5550         return NULL;
5551         }
5552     }
5553 {
5554     wxPy_BEGIN_ALLOW_THREADS;
5555         _result = (bool )wxGridTableBase_CanHaveAttributes(_arg0);
5556
5557     wxPy_END_ALLOW_THREADS;
5558     if (PyErr_Occurred()) return NULL;
5559 }    _resultobj = Py_BuildValue("i",_result);
5560     return _resultobj;
5561 }
5562
5563 #define wxGridTableBase_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
5564 static PyObject *_wrap_wxGridTableBase_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5565     PyObject * _resultobj;
5566     wxGridCellAttr * _result;
5567     wxGridTableBase * _arg0;
5568     int  _arg1;
5569     int  _arg2;
5570     wxGridCellAttr::wxAttrKind  _arg3;
5571     PyObject * _argo0 = 0;
5572     char *_kwnames[] = { "self","row","col","kind", NULL };
5573     char _ptemp[128];
5574
5575     self = self;
5576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5577         return NULL;
5578     if (_argo0) {
5579         if (_argo0 == Py_None) { _arg0 = NULL; }
5580         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5581             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetAttr. Expected _wxGridTableBase_p.");
5582         return NULL;
5583         }
5584     }
5585 {
5586     wxPy_BEGIN_ALLOW_THREADS;
5587         _result = (wxGridCellAttr *)wxGridTableBase_GetAttr(_arg0,_arg1,_arg2,_arg3);
5588
5589     wxPy_END_ALLOW_THREADS;
5590     if (PyErr_Occurred()) return NULL;
5591 }    if (_result) {
5592         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
5593         _resultobj = Py_BuildValue("s",_ptemp);
5594     } else {
5595         Py_INCREF(Py_None);
5596         _resultobj = Py_None;
5597     }
5598     return _resultobj;
5599 }
5600
5601 #define wxGridTableBase_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetAttr(_swigarg0,_swigarg1,_swigarg2))
5602 static PyObject *_wrap_wxGridTableBase_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5603     PyObject * _resultobj;
5604     wxGridTableBase * _arg0;
5605     wxGridCellAttr * _arg1;
5606     int  _arg2;
5607     int  _arg3;
5608     PyObject * _argo0 = 0;
5609     PyObject * _argo1 = 0;
5610     char *_kwnames[] = { "self","attr","row","col", NULL };
5611
5612     self = self;
5613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridTableBase_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
5614         return NULL;
5615     if (_argo0) {
5616         if (_argo0 == Py_None) { _arg0 = NULL; }
5617         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5618             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetAttr. Expected _wxGridTableBase_p.");
5619         return NULL;
5620         }
5621     }
5622     if (_argo1) {
5623         if (_argo1 == Py_None) { _arg1 = NULL; }
5624         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5625             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetAttr. Expected _wxGridCellAttr_p.");
5626         return NULL;
5627         }
5628     }
5629 {
5630     wxPy_BEGIN_ALLOW_THREADS;
5631         wxGridTableBase_SetAttr(_arg0,_arg1,_arg2,_arg3);
5632
5633     wxPy_END_ALLOW_THREADS;
5634     if (PyErr_Occurred()) return NULL;
5635 }    Py_INCREF(Py_None);
5636     _resultobj = Py_None;
5637     return _resultobj;
5638 }
5639
5640 #define wxGridTableBase_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
5641 static PyObject *_wrap_wxGridTableBase_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5642     PyObject * _resultobj;
5643     wxGridTableBase * _arg0;
5644     wxGridCellAttr * _arg1;
5645     int  _arg2;
5646     PyObject * _argo0 = 0;
5647     PyObject * _argo1 = 0;
5648     char *_kwnames[] = { "self","attr","row", NULL };
5649
5650     self = self;
5651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridTableBase_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
5652         return NULL;
5653     if (_argo0) {
5654         if (_argo0 == Py_None) { _arg0 = NULL; }
5655         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5656             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetRowAttr. Expected _wxGridTableBase_p.");
5657         return NULL;
5658         }
5659     }
5660     if (_argo1) {
5661         if (_argo1 == Py_None) { _arg1 = NULL; }
5662         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5663             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetRowAttr. Expected _wxGridCellAttr_p.");
5664         return NULL;
5665         }
5666     }
5667 {
5668     wxPy_BEGIN_ALLOW_THREADS;
5669         wxGridTableBase_SetRowAttr(_arg0,_arg1,_arg2);
5670
5671     wxPy_END_ALLOW_THREADS;
5672     if (PyErr_Occurred()) return NULL;
5673 }    Py_INCREF(Py_None);
5674     _resultobj = Py_None;
5675     return _resultobj;
5676 }
5677
5678 #define wxGridTableBase_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
5679 static PyObject *_wrap_wxGridTableBase_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5680     PyObject * _resultobj;
5681     wxGridTableBase * _arg0;
5682     wxGridCellAttr * _arg1;
5683     int  _arg2;
5684     PyObject * _argo0 = 0;
5685     PyObject * _argo1 = 0;
5686     char *_kwnames[] = { "self","attr","col", NULL };
5687
5688     self = self;
5689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridTableBase_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
5690         return NULL;
5691     if (_argo0) {
5692         if (_argo0 == Py_None) { _arg0 = NULL; }
5693         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5694             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetColAttr. Expected _wxGridTableBase_p.");
5695         return NULL;
5696         }
5697     }
5698     if (_argo1) {
5699         if (_argo1 == Py_None) { _arg1 = NULL; }
5700         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5701             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetColAttr. Expected _wxGridCellAttr_p.");
5702         return NULL;
5703         }
5704     }
5705 {
5706     wxPy_BEGIN_ALLOW_THREADS;
5707         wxGridTableBase_SetColAttr(_arg0,_arg1,_arg2);
5708
5709     wxPy_END_ALLOW_THREADS;
5710     if (PyErr_Occurred()) return NULL;
5711 }    Py_INCREF(Py_None);
5712     _resultobj = Py_None;
5713     return _resultobj;
5714 }
5715
5716 static void *SwigwxPyGridTableBaseTowxGridTableBase(void *ptr) {
5717     wxPyGridTableBase *src;
5718     wxGridTableBase *dest;
5719     src = (wxPyGridTableBase *) ptr;
5720     dest = (wxGridTableBase *) src;
5721     return (void *) dest;
5722 }
5723
5724 static void *SwigwxPyGridTableBaseTowxObject(void *ptr) {
5725     wxPyGridTableBase *src;
5726     wxObject *dest;
5727     src = (wxPyGridTableBase *) ptr;
5728     dest = (wxObject *) src;
5729     return (void *) dest;
5730 }
5731
5732 #define new_wxPyGridTableBase() (new wxPyGridTableBase())
5733 static PyObject *_wrap_new_wxPyGridTableBase(PyObject *self, PyObject *args, PyObject *kwargs) {
5734     PyObject * _resultobj;
5735     wxPyGridTableBase * _result;
5736     char *_kwnames[] = {  NULL };
5737     char _ptemp[128];
5738
5739     self = self;
5740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridTableBase",_kwnames))
5741         return NULL;
5742 {
5743     wxPy_BEGIN_ALLOW_THREADS;
5744         _result = (wxPyGridTableBase *)new_wxPyGridTableBase();
5745
5746     wxPy_END_ALLOW_THREADS;
5747     if (PyErr_Occurred()) return NULL;
5748 }    if (_result) {
5749         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridTableBase_p");
5750         _resultobj = Py_BuildValue("s",_ptemp);
5751     } else {
5752         Py_INCREF(Py_None);
5753         _resultobj = Py_None;
5754     }
5755     return _resultobj;
5756 }
5757
5758 #define wxPyGridTableBase__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
5759 static PyObject *_wrap_wxPyGridTableBase__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
5760     PyObject * _resultobj;
5761     wxPyGridTableBase * _arg0;
5762     PyObject * _arg1;
5763     PyObject * _arg2;
5764     PyObject * _argo0 = 0;
5765     PyObject * _obj1 = 0;
5766     PyObject * _obj2 = 0;
5767     char *_kwnames[] = { "self","self","_class", NULL };
5768
5769     self = self;
5770     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridTableBase__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
5771         return NULL;
5772     if (_argo0) {
5773         if (_argo0 == Py_None) { _arg0 = NULL; }
5774         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5775             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase__setCallbackInfo. Expected _wxPyGridTableBase_p.");
5776         return NULL;
5777         }
5778     }
5779 {
5780   _arg1 = _obj1;
5781 }
5782 {
5783   _arg2 = _obj2;
5784 }
5785 {
5786     wxPy_BEGIN_ALLOW_THREADS;
5787         wxPyGridTableBase__setCallbackInfo(_arg0,_arg1,_arg2);
5788
5789     wxPy_END_ALLOW_THREADS;
5790     if (PyErr_Occurred()) return NULL;
5791 }    Py_INCREF(Py_None);
5792     _resultobj = Py_None;
5793     return _resultobj;
5794 }
5795
5796 static void  wxPyGridTableBase_Destroy(wxPyGridTableBase *self) { delete self; }
5797 static PyObject *_wrap_wxPyGridTableBase_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
5798     PyObject * _resultobj;
5799     wxPyGridTableBase * _arg0;
5800     PyObject * _argo0 = 0;
5801     char *_kwnames[] = { "self", NULL };
5802
5803     self = self;
5804     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_Destroy",_kwnames,&_argo0))
5805         return NULL;
5806     if (_argo0) {
5807         if (_argo0 == Py_None) { _arg0 = NULL; }
5808         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5809             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_Destroy. Expected _wxPyGridTableBase_p.");
5810         return NULL;
5811         }
5812     }
5813 {
5814     wxPy_BEGIN_ALLOW_THREADS;
5815         wxPyGridTableBase_Destroy(_arg0);
5816
5817     wxPy_END_ALLOW_THREADS;
5818     if (PyErr_Occurred()) return NULL;
5819 }    Py_INCREF(Py_None);
5820     _resultobj = Py_None;
5821     return _resultobj;
5822 }
5823
5824 #define wxPyGridTableBase_base_GetTypeName(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_GetTypeName(_swigarg0,_swigarg1))
5825 static PyObject *_wrap_wxPyGridTableBase_base_GetTypeName(PyObject *self, PyObject *args, PyObject *kwargs) {
5826     PyObject * _resultobj;
5827     wxString * _result;
5828     wxPyGridTableBase * _arg0;
5829     int  _arg1;
5830     int  _arg2;
5831     PyObject * _argo0 = 0;
5832     char *_kwnames[] = { "self","row","col", NULL };
5833
5834     self = self;
5835     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxPyGridTableBase_base_GetTypeName",_kwnames,&_argo0,&_arg1,&_arg2))
5836         return NULL;
5837     if (_argo0) {
5838         if (_argo0 == Py_None) { _arg0 = NULL; }
5839         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5840             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetTypeName. Expected _wxPyGridTableBase_p.");
5841         return NULL;
5842         }
5843     }
5844 {
5845     wxPy_BEGIN_ALLOW_THREADS;
5846         _result = new wxString (wxPyGridTableBase_base_GetTypeName(_arg0,_arg1,_arg2));
5847
5848     wxPy_END_ALLOW_THREADS;
5849     if (PyErr_Occurred()) return NULL;
5850 }{
5851     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5852 }
5853 {
5854     delete _result;
5855 }
5856     return _resultobj;
5857 }
5858
5859 #define wxPyGridTableBase_base_CanGetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_CanGetValueAs(_swigarg0,_swigarg1,_swigarg2))
5860 static PyObject *_wrap_wxPyGridTableBase_base_CanGetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
5861     PyObject * _resultobj;
5862     bool  _result;
5863     wxPyGridTableBase * _arg0;
5864     int  _arg1;
5865     int  _arg2;
5866     wxString * _arg3;
5867     PyObject * _argo0 = 0;
5868     PyObject * _obj3 = 0;
5869     char *_kwnames[] = { "self","row","col","typeName", NULL };
5870
5871     self = self;
5872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxPyGridTableBase_base_CanGetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
5873         return NULL;
5874     if (_argo0) {
5875         if (_argo0 == Py_None) { _arg0 = NULL; }
5876         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5877             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanGetValueAs. Expected _wxPyGridTableBase_p.");
5878         return NULL;
5879         }
5880     }
5881 {
5882 #if PYTHON_API_VERSION >= 1009
5883     char* tmpPtr; int tmpSize;
5884     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
5885         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5886         return NULL;
5887     }
5888     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
5889         return NULL;
5890     _arg3 = new wxString(tmpPtr, tmpSize);
5891 #else
5892     if (!PyString_Check(_obj3)) {
5893         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5894         return NULL;
5895     }
5896     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
5897 #endif
5898 }
5899 {
5900     wxPy_BEGIN_ALLOW_THREADS;
5901         _result = (bool )wxPyGridTableBase_base_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
5902
5903     wxPy_END_ALLOW_THREADS;
5904     if (PyErr_Occurred()) return NULL;
5905 }    _resultobj = Py_BuildValue("i",_result);
5906 {
5907     if (_obj3)
5908         delete _arg3;
5909 }
5910     return _resultobj;
5911 }
5912
5913 #define wxPyGridTableBase_base_CanSetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_CanSetValueAs(_swigarg0,_swigarg1,_swigarg2))
5914 static PyObject *_wrap_wxPyGridTableBase_base_CanSetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
5915     PyObject * _resultobj;
5916     bool  _result;
5917     wxPyGridTableBase * _arg0;
5918     int  _arg1;
5919     int  _arg2;
5920     wxString * _arg3;
5921     PyObject * _argo0 = 0;
5922     PyObject * _obj3 = 0;
5923     char *_kwnames[] = { "self","row","col","typeName", NULL };
5924
5925     self = self;
5926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxPyGridTableBase_base_CanSetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
5927         return NULL;
5928     if (_argo0) {
5929         if (_argo0 == Py_None) { _arg0 = NULL; }
5930         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5931             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanSetValueAs. Expected _wxPyGridTableBase_p.");
5932         return NULL;
5933         }
5934     }
5935 {
5936 #if PYTHON_API_VERSION >= 1009
5937     char* tmpPtr; int tmpSize;
5938     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
5939         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5940         return NULL;
5941     }
5942     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
5943         return NULL;
5944     _arg3 = new wxString(tmpPtr, tmpSize);
5945 #else
5946     if (!PyString_Check(_obj3)) {
5947         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5948         return NULL;
5949     }
5950     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
5951 #endif
5952 }
5953 {
5954     wxPy_BEGIN_ALLOW_THREADS;
5955         _result = (bool )wxPyGridTableBase_base_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
5956
5957     wxPy_END_ALLOW_THREADS;
5958     if (PyErr_Occurred()) return NULL;
5959 }    _resultobj = Py_BuildValue("i",_result);
5960 {
5961     if (_obj3)
5962         delete _arg3;
5963 }
5964     return _resultobj;
5965 }
5966
5967 #define wxPyGridTableBase_base_Clear(_swigobj)  (_swigobj->base_Clear())
5968 static PyObject *_wrap_wxPyGridTableBase_base_Clear(PyObject *self, PyObject *args, PyObject *kwargs) {
5969     PyObject * _resultobj;
5970     wxPyGridTableBase * _arg0;
5971     PyObject * _argo0 = 0;
5972     char *_kwnames[] = { "self", NULL };
5973
5974     self = self;
5975     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_base_Clear",_kwnames,&_argo0))
5976         return NULL;
5977     if (_argo0) {
5978         if (_argo0 == Py_None) { _arg0 = NULL; }
5979         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5980             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_Clear. Expected _wxPyGridTableBase_p.");
5981         return NULL;
5982         }
5983     }
5984 {
5985     wxPy_BEGIN_ALLOW_THREADS;
5986         wxPyGridTableBase_base_Clear(_arg0);
5987
5988     wxPy_END_ALLOW_THREADS;
5989     if (PyErr_Occurred()) return NULL;
5990 }    Py_INCREF(Py_None);
5991     _resultobj = Py_None;
5992     return _resultobj;
5993 }
5994
5995 #define wxPyGridTableBase_base_InsertRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_InsertRows(_swigarg0,_swigarg1))
5996 static PyObject *_wrap_wxPyGridTableBase_base_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5997     PyObject * _resultobj;
5998     bool  _result;
5999     wxPyGridTableBase * _arg0;
6000     size_t  _arg1 = (size_t ) 0;
6001     size_t  _arg2 = (size_t ) 1;
6002     PyObject * _argo0 = 0;
6003     char *_kwnames[] = { "self","pos","numRows", NULL };
6004
6005     self = self;
6006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2))
6007         return NULL;
6008     if (_argo0) {
6009         if (_argo0 == Py_None) { _arg0 = NULL; }
6010         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6011             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_InsertRows. Expected _wxPyGridTableBase_p.");
6012         return NULL;
6013         }
6014     }
6015 {
6016     wxPy_BEGIN_ALLOW_THREADS;
6017         _result = (bool )wxPyGridTableBase_base_InsertRows(_arg0,_arg1,_arg2);
6018
6019     wxPy_END_ALLOW_THREADS;
6020     if (PyErr_Occurred()) return NULL;
6021 }    _resultobj = Py_BuildValue("i",_result);
6022     return _resultobj;
6023 }
6024
6025 #define wxPyGridTableBase_base_AppendRows(_swigobj,_swigarg0)  (_swigobj->base_AppendRows(_swigarg0))
6026 static PyObject *_wrap_wxPyGridTableBase_base_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
6027     PyObject * _resultobj;
6028     bool  _result;
6029     wxPyGridTableBase * _arg0;
6030     size_t  _arg1 = (size_t ) 1;
6031     PyObject * _argo0 = 0;
6032     char *_kwnames[] = { "self","numRows", NULL };
6033
6034     self = self;
6035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxPyGridTableBase_base_AppendRows",_kwnames,&_argo0,&_arg1))
6036         return NULL;
6037     if (_argo0) {
6038         if (_argo0 == Py_None) { _arg0 = NULL; }
6039         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6040             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_AppendRows. Expected _wxPyGridTableBase_p.");
6041         return NULL;
6042         }
6043     }
6044 {
6045     wxPy_BEGIN_ALLOW_THREADS;
6046         _result = (bool )wxPyGridTableBase_base_AppendRows(_arg0,_arg1);
6047
6048     wxPy_END_ALLOW_THREADS;
6049     if (PyErr_Occurred()) return NULL;
6050 }    _resultobj = Py_BuildValue("i",_result);
6051     return _resultobj;
6052 }
6053
6054 #define wxPyGridTableBase_base_DeleteRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DeleteRows(_swigarg0,_swigarg1))
6055 static PyObject *_wrap_wxPyGridTableBase_base_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
6056     PyObject * _resultobj;
6057     bool  _result;
6058     wxPyGridTableBase * _arg0;
6059     size_t  _arg1 = (size_t ) 0;
6060     size_t  _arg2 = (size_t ) 1;
6061     PyObject * _argo0 = 0;
6062     char *_kwnames[] = { "self","pos","numRows", NULL };
6063
6064     self = self;
6065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2))
6066         return NULL;
6067     if (_argo0) {
6068         if (_argo0 == Py_None) { _arg0 = NULL; }
6069         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6070             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_DeleteRows. Expected _wxPyGridTableBase_p.");
6071         return NULL;
6072         }
6073     }
6074 {
6075     wxPy_BEGIN_ALLOW_THREADS;
6076         _result = (bool )wxPyGridTableBase_base_DeleteRows(_arg0,_arg1,_arg2);
6077
6078     wxPy_END_ALLOW_THREADS;
6079     if (PyErr_Occurred()) return NULL;
6080 }    _resultobj = Py_BuildValue("i",_result);
6081     return _resultobj;
6082 }
6083
6084 #define wxPyGridTableBase_base_InsertCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_InsertCols(_swigarg0,_swigarg1))
6085 static PyObject *_wrap_wxPyGridTableBase_base_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6086     PyObject * _resultobj;
6087     bool  _result;
6088     wxPyGridTableBase * _arg0;
6089     size_t  _arg1 = (size_t ) 0;
6090     size_t  _arg2 = (size_t ) 1;
6091     PyObject * _argo0 = 0;
6092     char *_kwnames[] = { "self","pos","numCols", NULL };
6093
6094     self = self;
6095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2))
6096         return NULL;
6097     if (_argo0) {
6098         if (_argo0 == Py_None) { _arg0 = NULL; }
6099         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6100             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_InsertCols. Expected _wxPyGridTableBase_p.");
6101         return NULL;
6102         }
6103     }
6104 {
6105     wxPy_BEGIN_ALLOW_THREADS;
6106         _result = (bool )wxPyGridTableBase_base_InsertCols(_arg0,_arg1,_arg2);
6107
6108     wxPy_END_ALLOW_THREADS;
6109     if (PyErr_Occurred()) return NULL;
6110 }    _resultobj = Py_BuildValue("i",_result);
6111     return _resultobj;
6112 }
6113
6114 #define wxPyGridTableBase_base_AppendCols(_swigobj,_swigarg0)  (_swigobj->base_AppendCols(_swigarg0))
6115 static PyObject *_wrap_wxPyGridTableBase_base_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6116     PyObject * _resultobj;
6117     bool  _result;
6118     wxPyGridTableBase * _arg0;
6119     size_t  _arg1 = (size_t ) 1;
6120     PyObject * _argo0 = 0;
6121     char *_kwnames[] = { "self","numCols", NULL };
6122
6123     self = self;
6124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxPyGridTableBase_base_AppendCols",_kwnames,&_argo0,&_arg1))
6125         return NULL;
6126     if (_argo0) {
6127         if (_argo0 == Py_None) { _arg0 = NULL; }
6128         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6129             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_AppendCols. Expected _wxPyGridTableBase_p.");
6130         return NULL;
6131         }
6132     }
6133 {
6134     wxPy_BEGIN_ALLOW_THREADS;
6135         _result = (bool )wxPyGridTableBase_base_AppendCols(_arg0,_arg1);
6136
6137     wxPy_END_ALLOW_THREADS;
6138     if (PyErr_Occurred()) return NULL;
6139 }    _resultobj = Py_BuildValue("i",_result);
6140     return _resultobj;
6141 }
6142
6143 #define wxPyGridTableBase_base_DeleteCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DeleteCols(_swigarg0,_swigarg1))
6144 static PyObject *_wrap_wxPyGridTableBase_base_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6145     PyObject * _resultobj;
6146     bool  _result;
6147     wxPyGridTableBase * _arg0;
6148     size_t  _arg1 = (size_t ) 0;
6149     size_t  _arg2 = (size_t ) 1;
6150     PyObject * _argo0 = 0;
6151     char *_kwnames[] = { "self","pos","numCols", NULL };
6152
6153     self = self;
6154     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2))
6155         return NULL;
6156     if (_argo0) {
6157         if (_argo0 == Py_None) { _arg0 = NULL; }
6158         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6159             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_DeleteCols. Expected _wxPyGridTableBase_p.");
6160         return NULL;
6161         }
6162     }
6163 {
6164     wxPy_BEGIN_ALLOW_THREADS;
6165         _result = (bool )wxPyGridTableBase_base_DeleteCols(_arg0,_arg1,_arg2);
6166
6167     wxPy_END_ALLOW_THREADS;
6168     if (PyErr_Occurred()) return NULL;
6169 }    _resultobj = Py_BuildValue("i",_result);
6170     return _resultobj;
6171 }
6172
6173 #define wxPyGridTableBase_base_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->base_GetRowLabelValue(_swigarg0))
6174 static PyObject *_wrap_wxPyGridTableBase_base_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6175     PyObject * _resultobj;
6176     wxString * _result;
6177     wxPyGridTableBase * _arg0;
6178     int  _arg1;
6179     PyObject * _argo0 = 0;
6180     char *_kwnames[] = { "self","row", NULL };
6181
6182     self = self;
6183     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxPyGridTableBase_base_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
6184         return NULL;
6185     if (_argo0) {
6186         if (_argo0 == Py_None) { _arg0 = NULL; }
6187         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6188             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetRowLabelValue. Expected _wxPyGridTableBase_p.");
6189         return NULL;
6190         }
6191     }
6192 {
6193     wxPy_BEGIN_ALLOW_THREADS;
6194         _result = new wxString (wxPyGridTableBase_base_GetRowLabelValue(_arg0,_arg1));
6195
6196     wxPy_END_ALLOW_THREADS;
6197     if (PyErr_Occurred()) return NULL;
6198 }{
6199     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
6200 }
6201 {
6202     delete _result;
6203 }
6204     return _resultobj;
6205 }
6206
6207 #define wxPyGridTableBase_base_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->base_GetColLabelValue(_swigarg0))
6208 static PyObject *_wrap_wxPyGridTableBase_base_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6209     PyObject * _resultobj;
6210     wxString * _result;
6211     wxPyGridTableBase * _arg0;
6212     int  _arg1;
6213     PyObject * _argo0 = 0;
6214     char *_kwnames[] = { "self","col", NULL };
6215
6216     self = self;
6217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxPyGridTableBase_base_GetColLabelValue",_kwnames,&_argo0,&_arg1))
6218         return NULL;
6219     if (_argo0) {
6220         if (_argo0 == Py_None) { _arg0 = NULL; }
6221         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6222             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetColLabelValue. Expected _wxPyGridTableBase_p.");
6223         return NULL;
6224         }
6225     }
6226 {
6227     wxPy_BEGIN_ALLOW_THREADS;
6228         _result = new wxString (wxPyGridTableBase_base_GetColLabelValue(_arg0,_arg1));
6229
6230     wxPy_END_ALLOW_THREADS;
6231     if (PyErr_Occurred()) return NULL;
6232 }{
6233     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
6234 }
6235 {
6236     delete _result;
6237 }
6238     return _resultobj;
6239 }
6240
6241 #define wxPyGridTableBase_base_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowLabelValue(_swigarg0,_swigarg1))
6242 static PyObject *_wrap_wxPyGridTableBase_base_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6243     PyObject * _resultobj;
6244     wxPyGridTableBase * _arg0;
6245     int  _arg1;
6246     wxString * _arg2;
6247     PyObject * _argo0 = 0;
6248     PyObject * _obj2 = 0;
6249     char *_kwnames[] = { "self","row","value", NULL };
6250
6251     self = self;
6252     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxPyGridTableBase_base_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
6253         return NULL;
6254     if (_argo0) {
6255         if (_argo0 == Py_None) { _arg0 = NULL; }
6256         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6257             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetRowLabelValue. Expected _wxPyGridTableBase_p.");
6258         return NULL;
6259         }
6260     }
6261 {
6262 #if PYTHON_API_VERSION >= 1009
6263     char* tmpPtr; int tmpSize;
6264     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
6265         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6266         return NULL;
6267     }
6268     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
6269         return NULL;
6270     _arg2 = new wxString(tmpPtr, tmpSize);
6271 #else
6272     if (!PyString_Check(_obj2)) {
6273         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6274         return NULL;
6275     }
6276     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
6277 #endif
6278 }
6279 {
6280     wxPy_BEGIN_ALLOW_THREADS;
6281         wxPyGridTableBase_base_SetRowLabelValue(_arg0,_arg1,*_arg2);
6282
6283     wxPy_END_ALLOW_THREADS;
6284     if (PyErr_Occurred()) return NULL;
6285 }    Py_INCREF(Py_None);
6286     _resultobj = Py_None;
6287 {
6288     if (_obj2)
6289         delete _arg2;
6290 }
6291     return _resultobj;
6292 }
6293
6294 #define wxPyGridTableBase_base_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColLabelValue(_swigarg0,_swigarg1))
6295 static PyObject *_wrap_wxPyGridTableBase_base_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6296     PyObject * _resultobj;
6297     wxPyGridTableBase * _arg0;
6298     int  _arg1;
6299     wxString * _arg2;
6300     PyObject * _argo0 = 0;
6301     PyObject * _obj2 = 0;
6302     char *_kwnames[] = { "self","col","value", NULL };
6303
6304     self = self;
6305     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxPyGridTableBase_base_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
6306         return NULL;
6307     if (_argo0) {
6308         if (_argo0 == Py_None) { _arg0 = NULL; }
6309         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6310             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetColLabelValue. Expected _wxPyGridTableBase_p.");
6311         return NULL;
6312         }
6313     }
6314 {
6315 #if PYTHON_API_VERSION >= 1009
6316     char* tmpPtr; int tmpSize;
6317     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
6318         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6319         return NULL;
6320     }
6321     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
6322         return NULL;
6323     _arg2 = new wxString(tmpPtr, tmpSize);
6324 #else
6325     if (!PyString_Check(_obj2)) {
6326         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6327         return NULL;
6328     }
6329     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
6330 #endif
6331 }
6332 {
6333     wxPy_BEGIN_ALLOW_THREADS;
6334         wxPyGridTableBase_base_SetColLabelValue(_arg0,_arg1,*_arg2);
6335
6336     wxPy_END_ALLOW_THREADS;
6337     if (PyErr_Occurred()) return NULL;
6338 }    Py_INCREF(Py_None);
6339     _resultobj = Py_None;
6340 {
6341     if (_obj2)
6342         delete _arg2;
6343 }
6344     return _resultobj;
6345 }
6346
6347 #define wxPyGridTableBase_base_CanHaveAttributes(_swigobj)  (_swigobj->base_CanHaveAttributes())
6348 static PyObject *_wrap_wxPyGridTableBase_base_CanHaveAttributes(PyObject *self, PyObject *args, PyObject *kwargs) {
6349     PyObject * _resultobj;
6350     bool  _result;
6351     wxPyGridTableBase * _arg0;
6352     PyObject * _argo0 = 0;
6353     char *_kwnames[] = { "self", NULL };
6354
6355     self = self;
6356     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_base_CanHaveAttributes",_kwnames,&_argo0))
6357         return NULL;
6358     if (_argo0) {
6359         if (_argo0 == Py_None) { _arg0 = NULL; }
6360         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6361             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanHaveAttributes. Expected _wxPyGridTableBase_p.");
6362         return NULL;
6363         }
6364     }
6365 {
6366     wxPy_BEGIN_ALLOW_THREADS;
6367         _result = (bool )wxPyGridTableBase_base_CanHaveAttributes(_arg0);
6368
6369     wxPy_END_ALLOW_THREADS;
6370     if (PyErr_Occurred()) return NULL;
6371 }    _resultobj = Py_BuildValue("i",_result);
6372     return _resultobj;
6373 }
6374
6375 #define wxPyGridTableBase_base_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_GetAttr(_swigarg0,_swigarg1,_swigarg2))
6376 static PyObject *_wrap_wxPyGridTableBase_base_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6377     PyObject * _resultobj;
6378     wxGridCellAttr * _result;
6379     wxPyGridTableBase * _arg0;
6380     int  _arg1;
6381     int  _arg2;
6382     wxGridCellAttr::wxAttrKind  _arg3;
6383     PyObject * _argo0 = 0;
6384     char *_kwnames[] = { "self","row","col","kind", NULL };
6385     char _ptemp[128];
6386
6387     self = self;
6388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridTableBase_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
6389         return NULL;
6390     if (_argo0) {
6391         if (_argo0 == Py_None) { _arg0 = NULL; }
6392         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6393             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetAttr. Expected _wxPyGridTableBase_p.");
6394         return NULL;
6395         }
6396     }
6397 {
6398     wxPy_BEGIN_ALLOW_THREADS;
6399         _result = (wxGridCellAttr *)wxPyGridTableBase_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
6400
6401     wxPy_END_ALLOW_THREADS;
6402     if (PyErr_Occurred()) return NULL;
6403 }    if (_result) {
6404         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
6405         _resultobj = Py_BuildValue("s",_ptemp);
6406     } else {
6407         Py_INCREF(Py_None);
6408         _resultobj = Py_None;
6409     }
6410     return _resultobj;
6411 }
6412
6413 #define wxPyGridTableBase_base_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_SetAttr(_swigarg0,_swigarg1,_swigarg2))
6414 static PyObject *_wrap_wxPyGridTableBase_base_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6415     PyObject * _resultobj;
6416     wxPyGridTableBase * _arg0;
6417     wxGridCellAttr * _arg1;
6418     int  _arg2;
6419     int  _arg3;
6420     PyObject * _argo0 = 0;
6421     PyObject * _argo1 = 0;
6422     char *_kwnames[] = { "self","attr","row","col", NULL };
6423
6424     self = self;
6425     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxPyGridTableBase_base_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
6426         return NULL;
6427     if (_argo0) {
6428         if (_argo0 == Py_None) { _arg0 = NULL; }
6429         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6430             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetAttr. Expected _wxPyGridTableBase_p.");
6431         return NULL;
6432         }
6433     }
6434     if (_argo1) {
6435         if (_argo1 == Py_None) { _arg1 = NULL; }
6436         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6437             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetAttr. Expected _wxGridCellAttr_p.");
6438         return NULL;
6439         }
6440     }
6441 {
6442     wxPy_BEGIN_ALLOW_THREADS;
6443         wxPyGridTableBase_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
6444
6445     wxPy_END_ALLOW_THREADS;
6446     if (PyErr_Occurred()) return NULL;
6447 }    Py_INCREF(Py_None);
6448     _resultobj = Py_None;
6449     return _resultobj;
6450 }
6451
6452 #define wxPyGridTableBase_base_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowAttr(_swigarg0,_swigarg1))
6453 static PyObject *_wrap_wxPyGridTableBase_base_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6454     PyObject * _resultobj;
6455     wxPyGridTableBase * _arg0;
6456     wxGridCellAttr * _arg1;
6457     int  _arg2;
6458     PyObject * _argo0 = 0;
6459     PyObject * _argo1 = 0;
6460     char *_kwnames[] = { "self","attr","row", NULL };
6461
6462     self = self;
6463     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridTableBase_base_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
6464         return NULL;
6465     if (_argo0) {
6466         if (_argo0 == Py_None) { _arg0 = NULL; }
6467         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6468             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetRowAttr. Expected _wxPyGridTableBase_p.");
6469         return NULL;
6470         }
6471     }
6472     if (_argo1) {
6473         if (_argo1 == Py_None) { _arg1 = NULL; }
6474         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6475             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetRowAttr. Expected _wxGridCellAttr_p.");
6476         return NULL;
6477         }
6478     }
6479 {
6480     wxPy_BEGIN_ALLOW_THREADS;
6481         wxPyGridTableBase_base_SetRowAttr(_arg0,_arg1,_arg2);
6482
6483     wxPy_END_ALLOW_THREADS;
6484     if (PyErr_Occurred()) return NULL;
6485 }    Py_INCREF(Py_None);
6486     _resultobj = Py_None;
6487     return _resultobj;
6488 }
6489
6490 #define wxPyGridTableBase_base_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColAttr(_swigarg0,_swigarg1))
6491 static PyObject *_wrap_wxPyGridTableBase_base_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6492     PyObject * _resultobj;
6493     wxPyGridTableBase * _arg0;
6494     wxGridCellAttr * _arg1;
6495     int  _arg2;
6496     PyObject * _argo0 = 0;
6497     PyObject * _argo1 = 0;
6498     char *_kwnames[] = { "self","attr","col", NULL };
6499
6500     self = self;
6501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridTableBase_base_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
6502         return NULL;
6503     if (_argo0) {
6504         if (_argo0 == Py_None) { _arg0 = NULL; }
6505         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6506             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetColAttr. Expected _wxPyGridTableBase_p.");
6507         return NULL;
6508         }
6509     }
6510     if (_argo1) {
6511         if (_argo1 == Py_None) { _arg1 = NULL; }
6512         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6513             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetColAttr. Expected _wxGridCellAttr_p.");
6514         return NULL;
6515         }
6516     }
6517 {
6518     wxPy_BEGIN_ALLOW_THREADS;
6519         wxPyGridTableBase_base_SetColAttr(_arg0,_arg1,_arg2);
6520
6521     wxPy_END_ALLOW_THREADS;
6522     if (PyErr_Occurred()) return NULL;
6523 }    Py_INCREF(Py_None);
6524     _resultobj = Py_None;
6525     return _resultobj;
6526 }
6527
6528 static void *SwigwxGridStringTableTowxGridTableBase(void *ptr) {
6529     wxGridStringTable *src;
6530     wxGridTableBase *dest;
6531     src = (wxGridStringTable *) ptr;
6532     dest = (wxGridTableBase *) src;
6533     return (void *) dest;
6534 }
6535
6536 static void *SwigwxGridStringTableTowxObject(void *ptr) {
6537     wxGridStringTable *src;
6538     wxObject *dest;
6539     src = (wxGridStringTable *) ptr;
6540     dest = (wxObject *) src;
6541     return (void *) dest;
6542 }
6543
6544 #define new_wxGridStringTable(_swigarg0,_swigarg1) (new wxGridStringTable(_swigarg0,_swigarg1))
6545 static PyObject *_wrap_new_wxGridStringTable(PyObject *self, PyObject *args, PyObject *kwargs) {
6546     PyObject * _resultobj;
6547     wxGridStringTable * _result;
6548     int  _arg0 = (int ) 0;
6549     int  _arg1 = (int ) 0;
6550     char *_kwnames[] = { "numRows","numCols", NULL };
6551     char _ptemp[128];
6552
6553     self = self;
6554     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridStringTable",_kwnames,&_arg0,&_arg1))
6555         return NULL;
6556 {
6557     wxPy_BEGIN_ALLOW_THREADS;
6558         _result = (wxGridStringTable *)new_wxGridStringTable(_arg0,_arg1);
6559
6560     wxPy_END_ALLOW_THREADS;
6561     if (PyErr_Occurred()) return NULL;
6562 }    if (_result) {
6563         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridStringTable_p");
6564         _resultobj = Py_BuildValue("s",_ptemp);
6565     } else {
6566         Py_INCREF(Py_None);
6567         _resultobj = Py_None;
6568     }
6569     return _resultobj;
6570 }
6571
6572 #define new_wxGridTableMessage(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxGridTableMessage(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
6573 static PyObject *_wrap_new_wxGridTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
6574     PyObject * _resultobj;
6575     wxGridTableMessage * _result;
6576     wxGridTableBase * _arg0;
6577     int  _arg1;
6578     int  _arg2 = (int ) -1;
6579     int  _arg3 = (int ) -1;
6580     PyObject * _argo0 = 0;
6581     char *_kwnames[] = { "table","id","comInt1","comInt2", NULL };
6582     char _ptemp[128];
6583
6584     self = self;
6585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|ii:new_wxGridTableMessage",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
6586         return NULL;
6587     if (_argo0) {
6588         if (_argo0 == Py_None) { _arg0 = NULL; }
6589         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
6590             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGridTableMessage. Expected _wxGridTableBase_p.");
6591         return NULL;
6592         }
6593     }
6594 {
6595     wxPy_BEGIN_ALLOW_THREADS;
6596         _result = (wxGridTableMessage *)new_wxGridTableMessage(_arg0,_arg1,_arg2,_arg3);
6597
6598     wxPy_END_ALLOW_THREADS;
6599     if (PyErr_Occurred()) return NULL;
6600 }    if (_result) {
6601         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridTableMessage_p");
6602         _resultobj = Py_BuildValue("s",_ptemp);
6603     } else {
6604         Py_INCREF(Py_None);
6605         _resultobj = Py_None;
6606     }
6607     return _resultobj;
6608 }
6609
6610 #define delete_wxGridTableMessage(_swigobj) (delete _swigobj)
6611 static PyObject *_wrap_delete_wxGridTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
6612     PyObject * _resultobj;
6613     wxGridTableMessage * _arg0;
6614     PyObject * _argo0 = 0;
6615     char *_kwnames[] = { "self", NULL };
6616
6617     self = self;
6618     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGridTableMessage",_kwnames,&_argo0))
6619         return NULL;
6620     if (_argo0) {
6621         if (_argo0 == Py_None) { _arg0 = NULL; }
6622         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6623             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGridTableMessage. Expected _wxGridTableMessage_p.");
6624         return NULL;
6625         }
6626     }
6627 {
6628     wxPy_BEGIN_ALLOW_THREADS;
6629         delete_wxGridTableMessage(_arg0);
6630
6631     wxPy_END_ALLOW_THREADS;
6632     if (PyErr_Occurred()) return NULL;
6633 }    Py_INCREF(Py_None);
6634     _resultobj = Py_None;
6635     return _resultobj;
6636 }
6637
6638 #define wxGridTableMessage_SetTableObject(_swigobj,_swigarg0)  (_swigobj->SetTableObject(_swigarg0))
6639 static PyObject *_wrap_wxGridTableMessage_SetTableObject(PyObject *self, PyObject *args, PyObject *kwargs) {
6640     PyObject * _resultobj;
6641     wxGridTableMessage * _arg0;
6642     wxGridTableBase * _arg1;
6643     PyObject * _argo0 = 0;
6644     PyObject * _argo1 = 0;
6645     char *_kwnames[] = { "self","table", NULL };
6646
6647     self = self;
6648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableMessage_SetTableObject",_kwnames,&_argo0,&_argo1))
6649         return NULL;
6650     if (_argo0) {
6651         if (_argo0 == Py_None) { _arg0 = NULL; }
6652         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6653             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetTableObject. Expected _wxGridTableMessage_p.");
6654         return NULL;
6655         }
6656     }
6657     if (_argo1) {
6658         if (_argo1 == Py_None) { _arg1 = NULL; }
6659         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableBase_p")) {
6660             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableMessage_SetTableObject. Expected _wxGridTableBase_p.");
6661         return NULL;
6662         }
6663     }
6664 {
6665     wxPy_BEGIN_ALLOW_THREADS;
6666         wxGridTableMessage_SetTableObject(_arg0,_arg1);
6667
6668     wxPy_END_ALLOW_THREADS;
6669     if (PyErr_Occurred()) return NULL;
6670 }    Py_INCREF(Py_None);
6671     _resultobj = Py_None;
6672     return _resultobj;
6673 }
6674
6675 #define wxGridTableMessage_GetTableObject(_swigobj)  (_swigobj->GetTableObject())
6676 static PyObject *_wrap_wxGridTableMessage_GetTableObject(PyObject *self, PyObject *args, PyObject *kwargs) {
6677     PyObject * _resultobj;
6678     wxGridTableBase * _result;
6679     wxGridTableMessage * _arg0;
6680     PyObject * _argo0 = 0;
6681     char *_kwnames[] = { "self", NULL };
6682
6683     self = self;
6684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetTableObject",_kwnames,&_argo0))
6685         return NULL;
6686     if (_argo0) {
6687         if (_argo0 == Py_None) { _arg0 = NULL; }
6688         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6689             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetTableObject. Expected _wxGridTableMessage_p.");
6690         return NULL;
6691         }
6692     }
6693 {
6694     wxPy_BEGIN_ALLOW_THREADS;
6695         _result = (wxGridTableBase *)wxGridTableMessage_GetTableObject(_arg0);
6696
6697     wxPy_END_ALLOW_THREADS;
6698     if (PyErr_Occurred()) return NULL;
6699 }{ _resultobj = wxPyMake_wxObject(_result); }
6700     return _resultobj;
6701 }
6702
6703 #define wxGridTableMessage_SetId(_swigobj,_swigarg0)  (_swigobj->SetId(_swigarg0))
6704 static PyObject *_wrap_wxGridTableMessage_SetId(PyObject *self, PyObject *args, PyObject *kwargs) {
6705     PyObject * _resultobj;
6706     wxGridTableMessage * _arg0;
6707     int  _arg1;
6708     PyObject * _argo0 = 0;
6709     char *_kwnames[] = { "self","id", NULL };
6710
6711     self = self;
6712     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetId",_kwnames,&_argo0,&_arg1))
6713         return NULL;
6714     if (_argo0) {
6715         if (_argo0 == Py_None) { _arg0 = NULL; }
6716         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6717             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetId. Expected _wxGridTableMessage_p.");
6718         return NULL;
6719         }
6720     }
6721 {
6722     wxPy_BEGIN_ALLOW_THREADS;
6723         wxGridTableMessage_SetId(_arg0,_arg1);
6724
6725     wxPy_END_ALLOW_THREADS;
6726     if (PyErr_Occurred()) return NULL;
6727 }    Py_INCREF(Py_None);
6728     _resultobj = Py_None;
6729     return _resultobj;
6730 }
6731
6732 #define wxGridTableMessage_GetId(_swigobj)  (_swigobj->GetId())
6733 static PyObject *_wrap_wxGridTableMessage_GetId(PyObject *self, PyObject *args, PyObject *kwargs) {
6734     PyObject * _resultobj;
6735     int  _result;
6736     wxGridTableMessage * _arg0;
6737     PyObject * _argo0 = 0;
6738     char *_kwnames[] = { "self", NULL };
6739
6740     self = self;
6741     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetId",_kwnames,&_argo0))
6742         return NULL;
6743     if (_argo0) {
6744         if (_argo0 == Py_None) { _arg0 = NULL; }
6745         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6746             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetId. Expected _wxGridTableMessage_p.");
6747         return NULL;
6748         }
6749     }
6750 {
6751     wxPy_BEGIN_ALLOW_THREADS;
6752         _result = (int )wxGridTableMessage_GetId(_arg0);
6753
6754     wxPy_END_ALLOW_THREADS;
6755     if (PyErr_Occurred()) return NULL;
6756 }    _resultobj = Py_BuildValue("i",_result);
6757     return _resultobj;
6758 }
6759
6760 #define wxGridTableMessage_SetCommandInt(_swigobj,_swigarg0)  (_swigobj->SetCommandInt(_swigarg0))
6761 static PyObject *_wrap_wxGridTableMessage_SetCommandInt(PyObject *self, PyObject *args, PyObject *kwargs) {
6762     PyObject * _resultobj;
6763     wxGridTableMessage * _arg0;
6764     int  _arg1;
6765     PyObject * _argo0 = 0;
6766     char *_kwnames[] = { "self","comInt1", NULL };
6767
6768     self = self;
6769     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetCommandInt",_kwnames,&_argo0,&_arg1))
6770         return NULL;
6771     if (_argo0) {
6772         if (_argo0 == Py_None) { _arg0 = NULL; }
6773         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6774             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetCommandInt. Expected _wxGridTableMessage_p.");
6775         return NULL;
6776         }
6777     }
6778 {
6779     wxPy_BEGIN_ALLOW_THREADS;
6780         wxGridTableMessage_SetCommandInt(_arg0,_arg1);
6781
6782     wxPy_END_ALLOW_THREADS;
6783     if (PyErr_Occurred()) return NULL;
6784 }    Py_INCREF(Py_None);
6785     _resultobj = Py_None;
6786     return _resultobj;
6787 }
6788
6789 #define wxGridTableMessage_GetCommandInt(_swigobj)  (_swigobj->GetCommandInt())
6790 static PyObject *_wrap_wxGridTableMessage_GetCommandInt(PyObject *self, PyObject *args, PyObject *kwargs) {
6791     PyObject * _resultobj;
6792     int  _result;
6793     wxGridTableMessage * _arg0;
6794     PyObject * _argo0 = 0;
6795     char *_kwnames[] = { "self", NULL };
6796
6797     self = self;
6798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetCommandInt",_kwnames,&_argo0))
6799         return NULL;
6800     if (_argo0) {
6801         if (_argo0 == Py_None) { _arg0 = NULL; }
6802         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6803             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetCommandInt. Expected _wxGridTableMessage_p.");
6804         return NULL;
6805         }
6806     }
6807 {
6808     wxPy_BEGIN_ALLOW_THREADS;
6809         _result = (int )wxGridTableMessage_GetCommandInt(_arg0);
6810
6811     wxPy_END_ALLOW_THREADS;
6812     if (PyErr_Occurred()) return NULL;
6813 }    _resultobj = Py_BuildValue("i",_result);
6814     return _resultobj;
6815 }
6816
6817 #define wxGridTableMessage_SetCommandInt2(_swigobj,_swigarg0)  (_swigobj->SetCommandInt2(_swigarg0))
6818 static PyObject *_wrap_wxGridTableMessage_SetCommandInt2(PyObject *self, PyObject *args, PyObject *kwargs) {
6819     PyObject * _resultobj;
6820     wxGridTableMessage * _arg0;
6821     int  _arg1;
6822     PyObject * _argo0 = 0;
6823     char *_kwnames[] = { "self","comInt2", NULL };
6824
6825     self = self;
6826     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetCommandInt2",_kwnames,&_argo0,&_arg1))
6827         return NULL;
6828     if (_argo0) {
6829         if (_argo0 == Py_None) { _arg0 = NULL; }
6830         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6831             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetCommandInt2. Expected _wxGridTableMessage_p.");
6832         return NULL;
6833         }
6834     }
6835 {
6836     wxPy_BEGIN_ALLOW_THREADS;
6837         wxGridTableMessage_SetCommandInt2(_arg0,_arg1);
6838
6839     wxPy_END_ALLOW_THREADS;
6840     if (PyErr_Occurred()) return NULL;
6841 }    Py_INCREF(Py_None);
6842     _resultobj = Py_None;
6843     return _resultobj;
6844 }
6845
6846 #define wxGridTableMessage_GetCommandInt2(_swigobj)  (_swigobj->GetCommandInt2())
6847 static PyObject *_wrap_wxGridTableMessage_GetCommandInt2(PyObject *self, PyObject *args, PyObject *kwargs) {
6848     PyObject * _resultobj;
6849     int  _result;
6850     wxGridTableMessage * _arg0;
6851     PyObject * _argo0 = 0;
6852     char *_kwnames[] = { "self", NULL };
6853
6854     self = self;
6855     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetCommandInt2",_kwnames,&_argo0))
6856         return NULL;
6857     if (_argo0) {
6858         if (_argo0 == Py_None) { _arg0 = NULL; }
6859         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6860             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetCommandInt2. Expected _wxGridTableMessage_p.");
6861         return NULL;
6862         }
6863     }
6864 {
6865     wxPy_BEGIN_ALLOW_THREADS;
6866         _result = (int )wxGridTableMessage_GetCommandInt2(_arg0);
6867
6868     wxPy_END_ALLOW_THREADS;
6869     if (PyErr_Occurred()) return NULL;
6870 }    _resultobj = Py_BuildValue("i",_result);
6871     return _resultobj;
6872 }
6873
6874 #define new_wxGridCellCoords(_swigarg0,_swigarg1) (new wxGridCellCoords(_swigarg0,_swigarg1))
6875 static PyObject *_wrap_new_wxGridCellCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
6876     PyObject * _resultobj;
6877     wxGridCellCoords * _result;
6878     int  _arg0 = (int ) -1;
6879     int  _arg1 = (int ) -1;
6880     char *_kwnames[] = { "r","c", NULL };
6881     char _ptemp[128];
6882
6883     self = self;
6884     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellCoords",_kwnames,&_arg0,&_arg1))
6885         return NULL;
6886 {
6887     wxPy_BEGIN_ALLOW_THREADS;
6888         _result = (wxGridCellCoords *)new_wxGridCellCoords(_arg0,_arg1);
6889
6890     wxPy_END_ALLOW_THREADS;
6891     if (PyErr_Occurred()) return NULL;
6892 }    if (_result) {
6893         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
6894         _resultobj = Py_BuildValue("s",_ptemp);
6895     } else {
6896         Py_INCREF(Py_None);
6897         _resultobj = Py_None;
6898     }
6899     return _resultobj;
6900 }
6901
6902 #define delete_wxGridCellCoords(_swigobj) (delete _swigobj)
6903 static PyObject *_wrap_delete_wxGridCellCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
6904     PyObject * _resultobj;
6905     wxGridCellCoords * _arg0;
6906     PyObject * _argo0 = 0;
6907     char *_kwnames[] = { "self", NULL };
6908
6909     self = self;
6910     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGridCellCoords",_kwnames,&_argo0))
6911         return NULL;
6912     if (_argo0) {
6913         if (_argo0 == Py_None) { _arg0 = NULL; }
6914         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6915             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGridCellCoords. Expected _wxGridCellCoords_p.");
6916         return NULL;
6917         }
6918     }
6919 {
6920     wxPy_BEGIN_ALLOW_THREADS;
6921         delete_wxGridCellCoords(_arg0);
6922
6923     wxPy_END_ALLOW_THREADS;
6924     if (PyErr_Occurred()) return NULL;
6925 }    Py_INCREF(Py_None);
6926     _resultobj = Py_None;
6927     return _resultobj;
6928 }
6929
6930 #define wxGridCellCoords_GetRow(_swigobj)  (_swigobj->GetRow())
6931 static PyObject *_wrap_wxGridCellCoords_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
6932     PyObject * _resultobj;
6933     int  _result;
6934     wxGridCellCoords * _arg0;
6935     PyObject * _argo0 = 0;
6936     char *_kwnames[] = { "self", NULL };
6937
6938     self = self;
6939     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_GetRow",_kwnames,&_argo0))
6940         return NULL;
6941     if (_argo0) {
6942         if (_argo0 == Py_None) { _arg0 = NULL; }
6943         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6944             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_GetRow. Expected _wxGridCellCoords_p.");
6945         return NULL;
6946         }
6947     }
6948 {
6949     wxPy_BEGIN_ALLOW_THREADS;
6950         _result = (int )wxGridCellCoords_GetRow(_arg0);
6951
6952     wxPy_END_ALLOW_THREADS;
6953     if (PyErr_Occurred()) return NULL;
6954 }    _resultobj = Py_BuildValue("i",_result);
6955     return _resultobj;
6956 }
6957
6958 #define wxGridCellCoords_SetRow(_swigobj,_swigarg0)  (_swigobj->SetRow(_swigarg0))
6959 static PyObject *_wrap_wxGridCellCoords_SetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
6960     PyObject * _resultobj;
6961     wxGridCellCoords * _arg0;
6962     int  _arg1;
6963     PyObject * _argo0 = 0;
6964     char *_kwnames[] = { "self","n", NULL };
6965
6966     self = self;
6967     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellCoords_SetRow",_kwnames,&_argo0,&_arg1))
6968         return NULL;
6969     if (_argo0) {
6970         if (_argo0 == Py_None) { _arg0 = NULL; }
6971         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6972             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_SetRow. Expected _wxGridCellCoords_p.");
6973         return NULL;
6974         }
6975     }
6976 {
6977     wxPy_BEGIN_ALLOW_THREADS;
6978         wxGridCellCoords_SetRow(_arg0,_arg1);
6979
6980     wxPy_END_ALLOW_THREADS;
6981     if (PyErr_Occurred()) return NULL;
6982 }    Py_INCREF(Py_None);
6983     _resultobj = Py_None;
6984     return _resultobj;
6985 }
6986
6987 #define wxGridCellCoords_GetCol(_swigobj)  (_swigobj->GetCol())
6988 static PyObject *_wrap_wxGridCellCoords_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
6989     PyObject * _resultobj;
6990     int  _result;
6991     wxGridCellCoords * _arg0;
6992     PyObject * _argo0 = 0;
6993     char *_kwnames[] = { "self", NULL };
6994
6995     self = self;
6996     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_GetCol",_kwnames,&_argo0))
6997         return NULL;
6998     if (_argo0) {
6999         if (_argo0 == Py_None) { _arg0 = NULL; }
7000         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7001             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_GetCol. Expected _wxGridCellCoords_p.");
7002         return NULL;
7003         }
7004     }
7005 {
7006     wxPy_BEGIN_ALLOW_THREADS;
7007         _result = (int )wxGridCellCoords_GetCol(_arg0);
7008
7009     wxPy_END_ALLOW_THREADS;
7010     if (PyErr_Occurred()) return NULL;
7011 }    _resultobj = Py_BuildValue("i",_result);
7012     return _resultobj;
7013 }
7014
7015 #define wxGridCellCoords_SetCol(_swigobj,_swigarg0)  (_swigobj->SetCol(_swigarg0))
7016 static PyObject *_wrap_wxGridCellCoords_SetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
7017     PyObject * _resultobj;
7018     wxGridCellCoords * _arg0;
7019     int  _arg1;
7020     PyObject * _argo0 = 0;
7021     char *_kwnames[] = { "self","n", NULL };
7022
7023     self = self;
7024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellCoords_SetCol",_kwnames,&_argo0,&_arg1))
7025         return NULL;
7026     if (_argo0) {
7027         if (_argo0 == Py_None) { _arg0 = NULL; }
7028         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7029             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_SetCol. Expected _wxGridCellCoords_p.");
7030         return NULL;
7031         }
7032     }
7033 {
7034     wxPy_BEGIN_ALLOW_THREADS;
7035         wxGridCellCoords_SetCol(_arg0,_arg1);
7036
7037     wxPy_END_ALLOW_THREADS;
7038     if (PyErr_Occurred()) return NULL;
7039 }    Py_INCREF(Py_None);
7040     _resultobj = Py_None;
7041     return _resultobj;
7042 }
7043
7044 #define wxGridCellCoords_Set(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Set(_swigarg0,_swigarg1))
7045 static PyObject *_wrap_wxGridCellCoords_Set(PyObject *self, PyObject *args, PyObject *kwargs) {
7046     PyObject * _resultobj;
7047     wxGridCellCoords * _arg0;
7048     int  _arg1;
7049     int  _arg2;
7050     PyObject * _argo0 = 0;
7051     char *_kwnames[] = { "self","row","col", NULL };
7052
7053     self = self;
7054     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellCoords_Set",_kwnames,&_argo0,&_arg1,&_arg2))
7055         return NULL;
7056     if (_argo0) {
7057         if (_argo0 == Py_None) { _arg0 = NULL; }
7058         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7059             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_Set. Expected _wxGridCellCoords_p.");
7060         return NULL;
7061         }
7062     }
7063 {
7064     wxPy_BEGIN_ALLOW_THREADS;
7065         wxGridCellCoords_Set(_arg0,_arg1,_arg2);
7066
7067     wxPy_END_ALLOW_THREADS;
7068     if (PyErr_Occurred()) return NULL;
7069 }    Py_INCREF(Py_None);
7070     _resultobj = Py_None;
7071     return _resultobj;
7072 }
7073
7074 static PyObject * wxGridCellCoords_asTuple(wxGridCellCoords *self) {
7075             PyObject* tup = PyTuple_New(2);
7076             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
7077             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
7078             return tup;
7079         }
7080 static PyObject *_wrap_wxGridCellCoords_asTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
7081     PyObject * _resultobj;
7082     PyObject * _result;
7083     wxGridCellCoords * _arg0;
7084     PyObject * _argo0 = 0;
7085     char *_kwnames[] = { "self", NULL };
7086
7087     self = self;
7088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_asTuple",_kwnames,&_argo0))
7089         return NULL;
7090     if (_argo0) {
7091         if (_argo0 == Py_None) { _arg0 = NULL; }
7092         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7093             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_asTuple. Expected _wxGridCellCoords_p.");
7094         return NULL;
7095         }
7096     }
7097 {
7098     wxPy_BEGIN_ALLOW_THREADS;
7099         _result = (PyObject *)wxGridCellCoords_asTuple(_arg0);
7100
7101     wxPy_END_ALLOW_THREADS;
7102     if (PyErr_Occurred()) return NULL;
7103 }{
7104   _resultobj = _result;
7105 }
7106     return _resultobj;
7107 }
7108
7109 static int  wxGridCellCoords___cmp__(wxGridCellCoords *self,const wxGridCellCoords & other) {
7110             return *self != other;
7111         }
7112 static PyObject *_wrap_wxGridCellCoords___cmp__(PyObject *self, PyObject *args, PyObject *kwargs) {
7113     PyObject * _resultobj;
7114     int  _result;
7115     wxGridCellCoords * _arg0;
7116     wxGridCellCoords * _arg1;
7117     PyObject * _argo0 = 0;
7118     PyObject * _argo1 = 0;
7119     char *_kwnames[] = { "self","other", NULL };
7120
7121     self = self;
7122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellCoords___cmp__",_kwnames,&_argo0,&_argo1))
7123         return NULL;
7124     if (_argo0) {
7125         if (_argo0 == Py_None) { _arg0 = NULL; }
7126         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7127             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords___cmp__. Expected _wxGridCellCoords_p.");
7128         return NULL;
7129         }
7130     }
7131     if (_argo1) {
7132         if (_argo1 == Py_None) { _arg1 = NULL; }
7133         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellCoords_p")) {
7134             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellCoords___cmp__. Expected _wxGridCellCoords_p.");
7135         return NULL;
7136         }
7137     }
7138 {
7139     wxPy_BEGIN_ALLOW_THREADS;
7140         _result = (int )wxGridCellCoords___cmp__(_arg0,*_arg1);
7141
7142     wxPy_END_ALLOW_THREADS;
7143     if (PyErr_Occurred()) return NULL;
7144 }    _resultobj = Py_BuildValue("i",_result);
7145     return _resultobj;
7146 }
7147
7148 static void *SwigwxGridTowxScrolledWindow(void *ptr) {
7149     wxGrid *src;
7150     wxScrolledWindow *dest;
7151     src = (wxGrid *) ptr;
7152     dest = (wxScrolledWindow *) src;
7153     return (void *) dest;
7154 }
7155
7156 static void *SwigwxGridTowxPanel(void *ptr) {
7157     wxGrid *src;
7158     wxPanel *dest;
7159     src = (wxGrid *) ptr;
7160     dest = (wxPanel *) src;
7161     return (void *) dest;
7162 }
7163
7164 static void *SwigwxGridTowxWindow(void *ptr) {
7165     wxGrid *src;
7166     wxWindow *dest;
7167     src = (wxGrid *) ptr;
7168     dest = (wxWindow *) src;
7169     return (void *) dest;
7170 }
7171
7172 static void *SwigwxGridTowxEvtHandler(void *ptr) {
7173     wxGrid *src;
7174     wxEvtHandler *dest;
7175     src = (wxGrid *) ptr;
7176     dest = (wxEvtHandler *) src;
7177     return (void *) dest;
7178 }
7179
7180 static void *SwigwxGridTowxObject(void *ptr) {
7181     wxGrid *src;
7182     wxObject *dest;
7183     src = (wxGrid *) ptr;
7184     dest = (wxObject *) src;
7185     return (void *) dest;
7186 }
7187
7188 #define new_wxGrid(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxGrid(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
7189 static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7190     PyObject * _resultobj;
7191     wxGrid * _result;
7192     wxWindow * _arg0;
7193     wxWindowID  _arg1;
7194     wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
7195     wxSize * _arg3 = (wxSize *) &wxDefaultSize;
7196     long  _arg4 = (long ) wxWANTS_CHARS;
7197     char * _arg5 = (char *) wxPanelNameStr;
7198     PyObject * _argo0 = 0;
7199     wxPoint  temp;
7200     PyObject * _obj2 = 0;
7201     wxSize  temp0;
7202     PyObject * _obj3 = 0;
7203     char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
7204     char _ptemp[128];
7205
7206     self = self;
7207     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxGrid",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
7208         return NULL;
7209     if (_argo0) {
7210         if (_argo0 == Py_None) { _arg0 = NULL; }
7211         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
7212             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGrid. Expected _wxWindow_p.");
7213         return NULL;
7214         }
7215     }
7216     if (_obj2)
7217 {
7218     _arg2 = &temp;
7219     if (! wxPoint_helper(_obj2, &_arg2))
7220         return NULL;
7221 }
7222     if (_obj3)
7223 {
7224     _arg3 = &temp0;
7225     if (! wxSize_helper(_obj3, &_arg3))
7226         return NULL;
7227 }
7228 {
7229     wxPy_BEGIN_ALLOW_THREADS;
7230         _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
7231
7232     wxPy_END_ALLOW_THREADS;
7233     if (PyErr_Occurred()) return NULL;
7234 }    if (_result) {
7235         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p");
7236         _resultobj = Py_BuildValue("s",_ptemp);
7237     } else {
7238         Py_INCREF(Py_None);
7239         _resultobj = Py_None;
7240     }
7241     return _resultobj;
7242 }
7243
7244 #define wxGrid_CreateGrid(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CreateGrid(_swigarg0,_swigarg1,_swigarg2))
7245 static PyObject *_wrap_wxGrid_CreateGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7246     PyObject * _resultobj;
7247     bool  _result;
7248     wxGrid * _arg0;
7249     int  _arg1;
7250     int  _arg2;
7251     WXGRIDSELECTIONMODES  _arg3 = (WXGRIDSELECTIONMODES ) wxGrid::wxGridSelectCells;
7252     PyObject * _argo0 = 0;
7253     char *_kwnames[] = { "self","numRows","numCols","selmode", NULL };
7254
7255     self = self;
7256     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_CreateGrid",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
7257         return NULL;
7258     if (_argo0) {
7259         if (_argo0 == Py_None) { _arg0 = NULL; }
7260         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7261             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CreateGrid. Expected _wxGrid_p.");
7262         return NULL;
7263         }
7264     }
7265 {
7266     wxPy_BEGIN_ALLOW_THREADS;
7267         _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3);
7268
7269     wxPy_END_ALLOW_THREADS;
7270     if (PyErr_Occurred()) return NULL;
7271 }    _resultobj = Py_BuildValue("i",_result);
7272     return _resultobj;
7273 }
7274
7275 #define wxGrid_SetSelectionMode(_swigobj,_swigarg0)  (_swigobj->SetSelectionMode(_swigarg0))
7276 static PyObject *_wrap_wxGrid_SetSelectionMode(PyObject *self, PyObject *args, PyObject *kwargs) {
7277     PyObject * _resultobj;
7278     wxGrid * _arg0;
7279     WXGRIDSELECTIONMODES  _arg1;
7280     PyObject * _argo0 = 0;
7281     char *_kwnames[] = { "self","selmode", NULL };
7282
7283     self = self;
7284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetSelectionMode",_kwnames,&_argo0,&_arg1))
7285         return NULL;
7286     if (_argo0) {
7287         if (_argo0 == Py_None) { _arg0 = NULL; }
7288         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7289             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionMode. Expected _wxGrid_p.");
7290         return NULL;
7291         }
7292     }
7293 {
7294     wxPy_BEGIN_ALLOW_THREADS;
7295         wxGrid_SetSelectionMode(_arg0,_arg1);
7296
7297     wxPy_END_ALLOW_THREADS;
7298     if (PyErr_Occurred()) return NULL;
7299 }    Py_INCREF(Py_None);
7300     _resultobj = Py_None;
7301     return _resultobj;
7302 }
7303
7304 #define wxGrid_GetNumberRows(_swigobj)  (_swigobj->GetNumberRows())
7305 static PyObject *_wrap_wxGrid_GetNumberRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7306     PyObject * _resultobj;
7307     int  _result;
7308     wxGrid * _arg0;
7309     PyObject * _argo0 = 0;
7310     char *_kwnames[] = { "self", NULL };
7311
7312     self = self;
7313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetNumberRows",_kwnames,&_argo0))
7314         return NULL;
7315     if (_argo0) {
7316         if (_argo0 == Py_None) { _arg0 = NULL; }
7317         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7318             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetNumberRows. Expected _wxGrid_p.");
7319         return NULL;
7320         }
7321     }
7322 {
7323     wxPy_BEGIN_ALLOW_THREADS;
7324         _result = (int )wxGrid_GetNumberRows(_arg0);
7325
7326     wxPy_END_ALLOW_THREADS;
7327     if (PyErr_Occurred()) return NULL;
7328 }    _resultobj = Py_BuildValue("i",_result);
7329     return _resultobj;
7330 }
7331
7332 #define wxGrid_GetNumberCols(_swigobj)  (_swigobj->GetNumberCols())
7333 static PyObject *_wrap_wxGrid_GetNumberCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7334     PyObject * _resultobj;
7335     int  _result;
7336     wxGrid * _arg0;
7337     PyObject * _argo0 = 0;
7338     char *_kwnames[] = { "self", NULL };
7339
7340     self = self;
7341     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetNumberCols",_kwnames,&_argo0))
7342         return NULL;
7343     if (_argo0) {
7344         if (_argo0 == Py_None) { _arg0 = NULL; }
7345         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7346             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetNumberCols. Expected _wxGrid_p.");
7347         return NULL;
7348         }
7349     }
7350 {
7351     wxPy_BEGIN_ALLOW_THREADS;
7352         _result = (int )wxGrid_GetNumberCols(_arg0);
7353
7354     wxPy_END_ALLOW_THREADS;
7355     if (PyErr_Occurred()) return NULL;
7356 }    _resultobj = Py_BuildValue("i",_result);
7357     return _resultobj;
7358 }
7359
7360 #define wxGrid_ProcessTableMessage(_swigobj,_swigarg0)  (_swigobj->ProcessTableMessage(_swigarg0))
7361 static PyObject *_wrap_wxGrid_ProcessTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
7362     PyObject * _resultobj;
7363     bool  _result;
7364     wxGrid * _arg0;
7365     wxGridTableMessage * _arg1;
7366     PyObject * _argo0 = 0;
7367     PyObject * _argo1 = 0;
7368     char *_kwnames[] = { "self","arg2", NULL };
7369
7370     self = self;
7371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_ProcessTableMessage",_kwnames,&_argo0,&_argo1))
7372         return NULL;
7373     if (_argo0) {
7374         if (_argo0 == Py_None) { _arg0 = NULL; }
7375         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7376             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ProcessTableMessage. Expected _wxGrid_p.");
7377         return NULL;
7378         }
7379     }
7380     if (_argo1) {
7381         if (_argo1 == Py_None) { _arg1 = NULL; }
7382         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableMessage_p")) {
7383             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_ProcessTableMessage. Expected _wxGridTableMessage_p.");
7384         return NULL;
7385         }
7386     }
7387 {
7388     wxPy_BEGIN_ALLOW_THREADS;
7389         _result = (bool )wxGrid_ProcessTableMessage(_arg0,*_arg1);
7390
7391     wxPy_END_ALLOW_THREADS;
7392     if (PyErr_Occurred()) return NULL;
7393 }    _resultobj = Py_BuildValue("i",_result);
7394     return _resultobj;
7395 }
7396
7397 #define wxGrid_GetTable(_swigobj)  (_swigobj->GetTable())
7398 static PyObject *_wrap_wxGrid_GetTable(PyObject *self, PyObject *args, PyObject *kwargs) {
7399     PyObject * _resultobj;
7400     wxGridTableBase * _result;
7401     wxGrid * _arg0;
7402     PyObject * _argo0 = 0;
7403     char *_kwnames[] = { "self", NULL };
7404
7405     self = self;
7406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetTable",_kwnames,&_argo0))
7407         return NULL;
7408     if (_argo0) {
7409         if (_argo0 == Py_None) { _arg0 = NULL; }
7410         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7411             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetTable. Expected _wxGrid_p.");
7412         return NULL;
7413         }
7414     }
7415 {
7416     wxPy_BEGIN_ALLOW_THREADS;
7417         _result = (wxGridTableBase *)wxGrid_GetTable(_arg0);
7418
7419     wxPy_END_ALLOW_THREADS;
7420     if (PyErr_Occurred()) return NULL;
7421 }{ _resultobj = wxPyMake_wxObject(_result); }
7422     return _resultobj;
7423 }
7424
7425 #define wxGrid_SetTable(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetTable(_swigarg0,_swigarg1,_swigarg2))
7426 static PyObject *_wrap_wxGrid_SetTable(PyObject *self, PyObject *args, PyObject *kwargs) {
7427     PyObject * _resultobj;
7428     bool  _result;
7429     wxGrid * _arg0;
7430     wxGridTableBase * _arg1;
7431     bool  _arg2 = (bool ) FALSE;
7432     WXGRIDSELECTIONMODES  _arg3 = (WXGRIDSELECTIONMODES ) wxGrid::wxGridSelectCells;
7433     PyObject * _argo0 = 0;
7434     PyObject * _argo1 = 0;
7435     int tempbool2 = (int) FALSE;
7436     char *_kwnames[] = { "self","table","takeOwnership","selmode", NULL };
7437
7438     self = self;
7439     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|ii:wxGrid_SetTable",_kwnames,&_argo0,&_argo1,&tempbool2,&_arg3))
7440         return NULL;
7441     if (_argo0) {
7442         if (_argo0 == Py_None) { _arg0 = NULL; }
7443         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7444             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetTable. Expected _wxGrid_p.");
7445         return NULL;
7446         }
7447     }
7448     if (_argo1) {
7449         if (_argo1 == Py_None) { _arg1 = NULL; }
7450         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableBase_p")) {
7451             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetTable. Expected _wxGridTableBase_p.");
7452         return NULL;
7453         }
7454     }
7455     _arg2 = (bool ) tempbool2;
7456 {
7457     wxPy_BEGIN_ALLOW_THREADS;
7458         _result = (bool )wxGrid_SetTable(_arg0,_arg1,_arg2,_arg3);
7459
7460     wxPy_END_ALLOW_THREADS;
7461     if (PyErr_Occurred()) return NULL;
7462 }    _resultobj = Py_BuildValue("i",_result);
7463     return _resultobj;
7464 }
7465
7466 #define wxGrid_ClearGrid(_swigobj)  (_swigobj->ClearGrid())
7467 static PyObject *_wrap_wxGrid_ClearGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7468     PyObject * _resultobj;
7469     wxGrid * _arg0;
7470     PyObject * _argo0 = 0;
7471     char *_kwnames[] = { "self", NULL };
7472
7473     self = self;
7474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ClearGrid",_kwnames,&_argo0))
7475         return NULL;
7476     if (_argo0) {
7477         if (_argo0 == Py_None) { _arg0 = NULL; }
7478         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7479             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ClearGrid. Expected _wxGrid_p.");
7480         return NULL;
7481         }
7482     }
7483 {
7484     wxPy_BEGIN_ALLOW_THREADS;
7485         wxGrid_ClearGrid(_arg0);
7486
7487     wxPy_END_ALLOW_THREADS;
7488     if (PyErr_Occurred()) return NULL;
7489 }    Py_INCREF(Py_None);
7490     _resultobj = Py_None;
7491     return _resultobj;
7492 }
7493
7494 #define wxGrid_InsertRows(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->InsertRows(_swigarg0,_swigarg1,_swigarg2))
7495 static PyObject *_wrap_wxGrid_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7496     PyObject * _resultobj;
7497     bool  _result;
7498     wxGrid * _arg0;
7499     int  _arg1 = (int ) 0;
7500     int  _arg2 = (int ) 1;
7501     bool  _arg3 = (bool ) TRUE;
7502     PyObject * _argo0 = 0;
7503     int tempbool3 = (int) TRUE;
7504     char *_kwnames[] = { "self","pos","numRows","updateLabels", NULL };
7505
7506     self = self;
7507     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7508         return NULL;
7509     if (_argo0) {
7510         if (_argo0 == Py_None) { _arg0 = NULL; }
7511         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7512             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_InsertRows. Expected _wxGrid_p.");
7513         return NULL;
7514         }
7515     }
7516     _arg3 = (bool ) tempbool3;
7517 {
7518     wxPy_BEGIN_ALLOW_THREADS;
7519         _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3);
7520
7521     wxPy_END_ALLOW_THREADS;
7522     if (PyErr_Occurred()) return NULL;
7523 }    _resultobj = Py_BuildValue("i",_result);
7524     return _resultobj;
7525 }
7526
7527 #define wxGrid_AppendRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AppendRows(_swigarg0,_swigarg1))
7528 static PyObject *_wrap_wxGrid_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7529     PyObject * _resultobj;
7530     bool  _result;
7531     wxGrid * _arg0;
7532     int  _arg1 = (int ) 1;
7533     bool  _arg2 = (bool ) TRUE;
7534     PyObject * _argo0 = 0;
7535     int tempbool2 = (int) TRUE;
7536     char *_kwnames[] = { "self","numRows","updateLabels", NULL };
7537
7538     self = self;
7539     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGrid_AppendRows",_kwnames,&_argo0,&_arg1,&tempbool2))
7540         return NULL;
7541     if (_argo0) {
7542         if (_argo0 == Py_None) { _arg0 = NULL; }
7543         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7544             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AppendRows. Expected _wxGrid_p.");
7545         return NULL;
7546         }
7547     }
7548     _arg2 = (bool ) tempbool2;
7549 {
7550     wxPy_BEGIN_ALLOW_THREADS;
7551         _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2);
7552
7553     wxPy_END_ALLOW_THREADS;
7554     if (PyErr_Occurred()) return NULL;
7555 }    _resultobj = Py_BuildValue("i",_result);
7556     return _resultobj;
7557 }
7558
7559 #define wxGrid_DeleteRows(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->DeleteRows(_swigarg0,_swigarg1,_swigarg2))
7560 static PyObject *_wrap_wxGrid_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7561     PyObject * _resultobj;
7562     bool  _result;
7563     wxGrid * _arg0;
7564     int  _arg1 = (int ) 0;
7565     int  _arg2 = (int ) 1;
7566     bool  _arg3 = (bool ) TRUE;
7567     PyObject * _argo0 = 0;
7568     int tempbool3 = (int) TRUE;
7569     char *_kwnames[] = { "self","pos","numRows","updateLabels", NULL };
7570
7571     self = self;
7572     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7573         return NULL;
7574     if (_argo0) {
7575         if (_argo0 == Py_None) { _arg0 = NULL; }
7576         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7577             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DeleteRows. Expected _wxGrid_p.");
7578         return NULL;
7579         }
7580     }
7581     _arg3 = (bool ) tempbool3;
7582 {
7583     wxPy_BEGIN_ALLOW_THREADS;
7584         _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3);
7585
7586     wxPy_END_ALLOW_THREADS;
7587     if (PyErr_Occurred()) return NULL;
7588 }    _resultobj = Py_BuildValue("i",_result);
7589     return _resultobj;
7590 }
7591
7592 #define wxGrid_InsertCols(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->InsertCols(_swigarg0,_swigarg1,_swigarg2))
7593 static PyObject *_wrap_wxGrid_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7594     PyObject * _resultobj;
7595     bool  _result;
7596     wxGrid * _arg0;
7597     int  _arg1 = (int ) 0;
7598     int  _arg2 = (int ) 1;
7599     bool  _arg3 = (bool ) TRUE;
7600     PyObject * _argo0 = 0;
7601     int tempbool3 = (int) TRUE;
7602     char *_kwnames[] = { "self","pos","numCols","updateLabels", NULL };
7603
7604     self = self;
7605     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7606         return NULL;
7607     if (_argo0) {
7608         if (_argo0 == Py_None) { _arg0 = NULL; }
7609         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7610             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_InsertCols. Expected _wxGrid_p.");
7611         return NULL;
7612         }
7613     }
7614     _arg3 = (bool ) tempbool3;
7615 {
7616     wxPy_BEGIN_ALLOW_THREADS;
7617         _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3);
7618
7619     wxPy_END_ALLOW_THREADS;
7620     if (PyErr_Occurred()) return NULL;
7621 }    _resultobj = Py_BuildValue("i",_result);
7622     return _resultobj;
7623 }
7624
7625 #define wxGrid_AppendCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AppendCols(_swigarg0,_swigarg1))
7626 static PyObject *_wrap_wxGrid_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7627     PyObject * _resultobj;
7628     bool  _result;
7629     wxGrid * _arg0;
7630     int  _arg1 = (int ) 1;
7631     bool  _arg2 = (bool ) TRUE;
7632     PyObject * _argo0 = 0;
7633     int tempbool2 = (int) TRUE;
7634     char *_kwnames[] = { "self","numCols","updateLabels", NULL };
7635
7636     self = self;
7637     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGrid_AppendCols",_kwnames,&_argo0,&_arg1,&tempbool2))
7638         return NULL;
7639     if (_argo0) {
7640         if (_argo0 == Py_None) { _arg0 = NULL; }
7641         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7642             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AppendCols. Expected _wxGrid_p.");
7643         return NULL;
7644         }
7645     }
7646     _arg2 = (bool ) tempbool2;
7647 {
7648     wxPy_BEGIN_ALLOW_THREADS;
7649         _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2);
7650
7651     wxPy_END_ALLOW_THREADS;
7652     if (PyErr_Occurred()) return NULL;
7653 }    _resultobj = Py_BuildValue("i",_result);
7654     return _resultobj;
7655 }
7656
7657 #define wxGrid_DeleteCols(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->DeleteCols(_swigarg0,_swigarg1,_swigarg2))
7658 static PyObject *_wrap_wxGrid_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7659     PyObject * _resultobj;
7660     bool  _result;
7661     wxGrid * _arg0;
7662     int  _arg1 = (int ) 0;
7663     int  _arg2 = (int ) 1;
7664     bool  _arg3 = (bool ) TRUE;
7665     PyObject * _argo0 = 0;
7666     int tempbool3 = (int) TRUE;
7667     char *_kwnames[] = { "self","pos","numCols","updateLabels", NULL };
7668
7669     self = self;
7670     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7671         return NULL;
7672     if (_argo0) {
7673         if (_argo0 == Py_None) { _arg0 = NULL; }
7674         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7675             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DeleteCols. Expected _wxGrid_p.");
7676         return NULL;
7677         }
7678     }
7679     _arg3 = (bool ) tempbool3;
7680 {
7681     wxPy_BEGIN_ALLOW_THREADS;
7682         _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3);
7683
7684     wxPy_END_ALLOW_THREADS;
7685     if (PyErr_Occurred()) return NULL;
7686 }    _resultobj = Py_BuildValue("i",_result);
7687     return _resultobj;
7688 }
7689
7690 #define wxGrid_DrawCellHighlight(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DrawCellHighlight(_swigarg0,_swigarg1))
7691 static PyObject *_wrap_wxGrid_DrawCellHighlight(PyObject *self, PyObject *args, PyObject *kwargs) {
7692     PyObject * _resultobj;
7693     wxGrid * _arg0;
7694     wxDC * _arg1;
7695     wxGridCellAttr * _arg2;
7696     PyObject * _argo0 = 0;
7697     PyObject * _argo1 = 0;
7698     PyObject * _argo2 = 0;
7699     char *_kwnames[] = { "self","dc","attr", NULL };
7700
7701     self = self;
7702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_DrawCellHighlight",_kwnames,&_argo0,&_argo1,&_argo2))
7703         return NULL;
7704     if (_argo0) {
7705         if (_argo0 == Py_None) { _arg0 = NULL; }
7706         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7707             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DrawCellHighlight. Expected _wxGrid_p.");
7708         return NULL;
7709         }
7710     }
7711     if (_argo1) {
7712         if (_argo1 == Py_None) { _arg1 = NULL; }
7713         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7714             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_DrawCellHighlight. Expected _wxDC_p.");
7715         return NULL;
7716         }
7717     }
7718     if (_argo2) {
7719         if (_argo2 == Py_None) { _arg2 = NULL; }
7720         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
7721             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_DrawCellHighlight. Expected _wxGridCellAttr_p.");
7722         return NULL;
7723         }
7724     }
7725 {
7726     wxPy_BEGIN_ALLOW_THREADS;
7727         wxGrid_DrawCellHighlight(_arg0,*_arg1,_arg2);
7728
7729     wxPy_END_ALLOW_THREADS;
7730     if (PyErr_Occurred()) return NULL;
7731 }    Py_INCREF(Py_None);
7732     _resultobj = Py_None;
7733     return _resultobj;
7734 }
7735
7736 #define wxGrid_DrawTextRectangle(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->DrawTextRectangle(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
7737 static PyObject *_wrap_wxGrid_DrawTextRectangle(PyObject *self, PyObject *args, PyObject *kwargs) {
7738     PyObject * _resultobj;
7739     wxGrid * _arg0;
7740     wxDC * _arg1;
7741     wxString * _arg2;
7742     wxRect * _arg3;
7743     int  _arg4 = (int ) wxLEFT;
7744     int  _arg5 = (int ) wxTOP;
7745     PyObject * _argo0 = 0;
7746     PyObject * _argo1 = 0;
7747     PyObject * _obj2 = 0;
7748     wxRect  temp;
7749     PyObject * _obj3 = 0;
7750     char *_kwnames[] = { "self","dc","arg3","arg4","horizontalAlignment","verticalAlignment", NULL };
7751
7752     self = self;
7753     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO|ii:wxGrid_DrawTextRectangle",_kwnames,&_argo0,&_argo1,&_obj2,&_obj3,&_arg4,&_arg5))
7754         return NULL;
7755     if (_argo0) {
7756         if (_argo0 == Py_None) { _arg0 = NULL; }
7757         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7758             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DrawTextRectangle. Expected _wxGrid_p.");
7759         return NULL;
7760         }
7761     }
7762     if (_argo1) {
7763         if (_argo1 == Py_None) { _arg1 = NULL; }
7764         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7765             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_DrawTextRectangle. Expected _wxDC_p.");
7766         return NULL;
7767         }
7768     }
7769 {
7770 #if PYTHON_API_VERSION >= 1009
7771     char* tmpPtr; int tmpSize;
7772     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
7773         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7774         return NULL;
7775     }
7776     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
7777         return NULL;
7778     _arg2 = new wxString(tmpPtr, tmpSize);
7779 #else
7780     if (!PyString_Check(_obj2)) {
7781         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7782         return NULL;
7783     }
7784     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
7785 #endif
7786 }
7787 {
7788     _arg3 = &temp;
7789     if (! wxRect_helper(_obj3, &_arg3))
7790         return NULL;
7791 }
7792 {
7793     wxPy_BEGIN_ALLOW_THREADS;
7794         wxGrid_DrawTextRectangle(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5);
7795
7796     wxPy_END_ALLOW_THREADS;
7797     if (PyErr_Occurred()) return NULL;
7798 }    Py_INCREF(Py_None);
7799     _resultobj = Py_None;
7800 {
7801     if (_obj2)
7802         delete _arg2;
7803 }
7804     return _resultobj;
7805 }
7806
7807 #define wxGrid_GetTextBoxSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetTextBoxSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
7808 static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
7809     PyObject * _resultobj;
7810     wxGrid * _arg0;
7811     wxDC * _arg1;
7812     wxArrayString * _arg2;
7813     long * _arg3;
7814     long  temp;
7815     long * _arg4;
7816     long  temp0;
7817     PyObject * _argo0 = 0;
7818     PyObject * _argo1 = 0;
7819     PyObject * _obj2 = 0;
7820     char *_kwnames[] = { "self","dc","lines", NULL };
7821
7822     self = self;
7823 {
7824   _arg3 = &temp;
7825 }
7826 {
7827   _arg4 = &temp0;
7828 }
7829     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetTextBoxSize",_kwnames,&_argo0,&_argo1,&_obj2))
7830         return NULL;
7831     if (_argo0) {
7832         if (_argo0 == Py_None) { _arg0 = NULL; }
7833         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7834             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetTextBoxSize. Expected _wxGrid_p.");
7835         return NULL;
7836         }
7837     }
7838     if (_argo1) {
7839         if (_argo1 == Py_None) { _arg1 = NULL; }
7840         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7841             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetTextBoxSize. Expected _wxDC_p.");
7842         return NULL;
7843         }
7844     }
7845 {
7846     if (! PySequence_Check(_obj2)) {
7847         PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7848         return NULL;
7849     }
7850     _arg2 = new wxArrayString;
7851     int i, len=PySequence_Length(_obj2);
7852     for (i=0; i<len; i++) {
7853         PyObject* item = PySequence_GetItem(_obj2, i);
7854         PyObject* str  = PyObject_Str(item);
7855         _arg2->Add(PyString_AsString(item));
7856         Py_DECREF(item);
7857         Py_DECREF(str);
7858     }
7859 }
7860 {
7861     wxPy_BEGIN_ALLOW_THREADS;
7862         wxGrid_GetTextBoxSize(_arg0,*_arg1,*_arg2,_arg3,_arg4);
7863
7864     wxPy_END_ALLOW_THREADS;
7865     if (PyErr_Occurred()) return NULL;
7866 }    Py_INCREF(Py_None);
7867     _resultobj = Py_None;
7868 {
7869     PyObject *o;
7870     o = PyInt_FromLong((long) (*_arg3));
7871     _resultobj = t_output_helper(_resultobj, o);
7872 }
7873 {
7874     PyObject *o;
7875     o = PyInt_FromLong((long) (*_arg4));
7876     _resultobj = t_output_helper(_resultobj, o);
7877 }
7878 {
7879     if (_obj2)
7880         delete _arg2;
7881 }
7882     return _resultobj;
7883 }
7884
7885 #define wxGrid_BeginBatch(_swigobj)  (_swigobj->BeginBatch())
7886 static PyObject *_wrap_wxGrid_BeginBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7887     PyObject * _resultobj;
7888     wxGrid * _arg0;
7889     PyObject * _argo0 = 0;
7890     char *_kwnames[] = { "self", NULL };
7891
7892     self = self;
7893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_BeginBatch",_kwnames,&_argo0))
7894         return NULL;
7895     if (_argo0) {
7896         if (_argo0 == Py_None) { _arg0 = NULL; }
7897         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7898             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BeginBatch. Expected _wxGrid_p.");
7899         return NULL;
7900         }
7901     }
7902 {
7903     wxPy_BEGIN_ALLOW_THREADS;
7904         wxGrid_BeginBatch(_arg0);
7905
7906     wxPy_END_ALLOW_THREADS;
7907     if (PyErr_Occurred()) return NULL;
7908 }    Py_INCREF(Py_None);
7909     _resultobj = Py_None;
7910     return _resultobj;
7911 }
7912
7913 #define wxGrid_EndBatch(_swigobj)  (_swigobj->EndBatch())
7914 static PyObject *_wrap_wxGrid_EndBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7915     PyObject * _resultobj;
7916     wxGrid * _arg0;
7917     PyObject * _argo0 = 0;
7918     char *_kwnames[] = { "self", NULL };
7919
7920     self = self;
7921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_EndBatch",_kwnames,&_argo0))
7922         return NULL;
7923     if (_argo0) {
7924         if (_argo0 == Py_None) { _arg0 = NULL; }
7925         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7926             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EndBatch. Expected _wxGrid_p.");
7927         return NULL;
7928         }
7929     }
7930 {
7931     wxPy_BEGIN_ALLOW_THREADS;
7932         wxGrid_EndBatch(_arg0);
7933
7934     wxPy_END_ALLOW_THREADS;
7935     if (PyErr_Occurred()) return NULL;
7936 }    Py_INCREF(Py_None);
7937     _resultobj = Py_None;
7938     return _resultobj;
7939 }
7940
7941 #define wxGrid_GetBatchCount(_swigobj)  (_swigobj->GetBatchCount())
7942 static PyObject *_wrap_wxGrid_GetBatchCount(PyObject *self, PyObject *args, PyObject *kwargs) {
7943     PyObject * _resultobj;
7944     int  _result;
7945     wxGrid * _arg0;
7946     PyObject * _argo0 = 0;
7947     char *_kwnames[] = { "self", NULL };
7948
7949     self = self;
7950     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetBatchCount",_kwnames,&_argo0))
7951         return NULL;
7952     if (_argo0) {
7953         if (_argo0 == Py_None) { _arg0 = NULL; }
7954         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7955             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetBatchCount. Expected _wxGrid_p.");
7956         return NULL;
7957         }
7958     }
7959 {
7960     wxPy_BEGIN_ALLOW_THREADS;
7961         _result = (int )wxGrid_GetBatchCount(_arg0);
7962
7963     wxPy_END_ALLOW_THREADS;
7964     if (PyErr_Occurred()) return NULL;
7965 }    _resultobj = Py_BuildValue("i",_result);
7966     return _resultobj;
7967 }
7968
7969 #define wxGrid_ForceRefresh(_swigobj)  (_swigobj->ForceRefresh())
7970 static PyObject *_wrap_wxGrid_ForceRefresh(PyObject *self, PyObject *args, PyObject *kwargs) {
7971     PyObject * _resultobj;
7972     wxGrid * _arg0;
7973     PyObject * _argo0 = 0;
7974     char *_kwnames[] = { "self", NULL };
7975
7976     self = self;
7977     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ForceRefresh",_kwnames,&_argo0))
7978         return NULL;
7979     if (_argo0) {
7980         if (_argo0 == Py_None) { _arg0 = NULL; }
7981         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7982             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ForceRefresh. Expected _wxGrid_p.");
7983         return NULL;
7984         }
7985     }
7986 {
7987     wxPy_BEGIN_ALLOW_THREADS;
7988         wxGrid_ForceRefresh(_arg0);
7989
7990     wxPy_END_ALLOW_THREADS;
7991     if (PyErr_Occurred()) return NULL;
7992 }    Py_INCREF(Py_None);
7993     _resultobj = Py_None;
7994     return _resultobj;
7995 }
7996
7997 #define wxGrid_IsEditable(_swigobj)  (_swigobj->IsEditable())
7998 static PyObject *_wrap_wxGrid_IsEditable(PyObject *self, PyObject *args, PyObject *kwargs) {
7999     PyObject * _resultobj;
8000     bool  _result;
8001     wxGrid * _arg0;
8002     PyObject * _argo0 = 0;
8003     char *_kwnames[] = { "self", NULL };
8004
8005     self = self;
8006     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsEditable",_kwnames,&_argo0))
8007         return NULL;
8008     if (_argo0) {
8009         if (_argo0 == Py_None) { _arg0 = NULL; }
8010         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8011             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsEditable. Expected _wxGrid_p.");
8012         return NULL;
8013         }
8014     }
8015 {
8016     wxPy_BEGIN_ALLOW_THREADS;
8017         _result = (bool )wxGrid_IsEditable(_arg0);
8018
8019     wxPy_END_ALLOW_THREADS;
8020     if (PyErr_Occurred()) return NULL;
8021 }    _resultobj = Py_BuildValue("i",_result);
8022     return _resultobj;
8023 }
8024
8025 #define wxGrid_EnableEditing(_swigobj,_swigarg0)  (_swigobj->EnableEditing(_swigarg0))
8026 static PyObject *_wrap_wxGrid_EnableEditing(PyObject *self, PyObject *args, PyObject *kwargs) {
8027     PyObject * _resultobj;
8028     wxGrid * _arg0;
8029     bool  _arg1;
8030     PyObject * _argo0 = 0;
8031     int tempbool1;
8032     char *_kwnames[] = { "self","edit", NULL };
8033
8034     self = self;
8035     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_EnableEditing",_kwnames,&_argo0,&tempbool1))
8036         return NULL;
8037     if (_argo0) {
8038         if (_argo0 == Py_None) { _arg0 = NULL; }
8039         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8040             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableEditing. Expected _wxGrid_p.");
8041         return NULL;
8042         }
8043     }
8044     _arg1 = (bool ) tempbool1;
8045 {
8046     wxPy_BEGIN_ALLOW_THREADS;
8047         wxGrid_EnableEditing(_arg0,_arg1);
8048
8049     wxPy_END_ALLOW_THREADS;
8050     if (PyErr_Occurred()) return NULL;
8051 }    Py_INCREF(Py_None);
8052     _resultobj = Py_None;
8053     return _resultobj;
8054 }
8055
8056 #define wxGrid_EnableCellEditControl(_swigobj,_swigarg0)  (_swigobj->EnableCellEditControl(_swigarg0))
8057 static PyObject *_wrap_wxGrid_EnableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8058     PyObject * _resultobj;
8059     wxGrid * _arg0;
8060     bool  _arg1 = (bool ) TRUE;
8061     PyObject * _argo0 = 0;
8062     int tempbool1 = (int) TRUE;
8063     char *_kwnames[] = { "self","enable", NULL };
8064
8065     self = self;
8066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableCellEditControl",_kwnames,&_argo0,&tempbool1))
8067         return NULL;
8068     if (_argo0) {
8069         if (_argo0 == Py_None) { _arg0 = NULL; }
8070         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8071             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableCellEditControl. Expected _wxGrid_p.");
8072         return NULL;
8073         }
8074     }
8075     _arg1 = (bool ) tempbool1;
8076 {
8077     wxPy_BEGIN_ALLOW_THREADS;
8078         wxGrid_EnableCellEditControl(_arg0,_arg1);
8079
8080     wxPy_END_ALLOW_THREADS;
8081     if (PyErr_Occurred()) return NULL;
8082 }    Py_INCREF(Py_None);
8083     _resultobj = Py_None;
8084     return _resultobj;
8085 }
8086
8087 #define wxGrid_DisableCellEditControl(_swigobj)  (_swigobj->DisableCellEditControl())
8088 static PyObject *_wrap_wxGrid_DisableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8089     PyObject * _resultobj;
8090     wxGrid * _arg0;
8091     PyObject * _argo0 = 0;
8092     char *_kwnames[] = { "self", NULL };
8093
8094     self = self;
8095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableCellEditControl",_kwnames,&_argo0))
8096         return NULL;
8097     if (_argo0) {
8098         if (_argo0 == Py_None) { _arg0 = NULL; }
8099         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8100             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableCellEditControl. Expected _wxGrid_p.");
8101         return NULL;
8102         }
8103     }
8104 {
8105     wxPy_BEGIN_ALLOW_THREADS;
8106         wxGrid_DisableCellEditControl(_arg0);
8107
8108     wxPy_END_ALLOW_THREADS;
8109     if (PyErr_Occurred()) return NULL;
8110 }    Py_INCREF(Py_None);
8111     _resultobj = Py_None;
8112     return _resultobj;
8113 }
8114
8115 #define wxGrid_CanEnableCellControl(_swigobj)  (_swigobj->CanEnableCellControl())
8116 static PyObject *_wrap_wxGrid_CanEnableCellControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8117     PyObject * _resultobj;
8118     bool  _result;
8119     wxGrid * _arg0;
8120     PyObject * _argo0 = 0;
8121     char *_kwnames[] = { "self", NULL };
8122
8123     self = self;
8124     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanEnableCellControl",_kwnames,&_argo0))
8125         return NULL;
8126     if (_argo0) {
8127         if (_argo0 == Py_None) { _arg0 = NULL; }
8128         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8129             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanEnableCellControl. Expected _wxGrid_p.");
8130         return NULL;
8131         }
8132     }
8133 {
8134     wxPy_BEGIN_ALLOW_THREADS;
8135         _result = (bool )wxGrid_CanEnableCellControl(_arg0);
8136
8137     wxPy_END_ALLOW_THREADS;
8138     if (PyErr_Occurred()) return NULL;
8139 }    _resultobj = Py_BuildValue("i",_result);
8140     return _resultobj;
8141 }
8142
8143 #define wxGrid_IsCellEditControlEnabled(_swigobj)  (_swigobj->IsCellEditControlEnabled())
8144 static PyObject *_wrap_wxGrid_IsCellEditControlEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
8145     PyObject * _resultobj;
8146     bool  _result;
8147     wxGrid * _arg0;
8148     PyObject * _argo0 = 0;
8149     char *_kwnames[] = { "self", NULL };
8150
8151     self = self;
8152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlEnabled",_kwnames,&_argo0))
8153         return NULL;
8154     if (_argo0) {
8155         if (_argo0 == Py_None) { _arg0 = NULL; }
8156         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8157             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlEnabled. Expected _wxGrid_p.");
8158         return NULL;
8159         }
8160     }
8161 {
8162     wxPy_BEGIN_ALLOW_THREADS;
8163         _result = (bool )wxGrid_IsCellEditControlEnabled(_arg0);
8164
8165     wxPy_END_ALLOW_THREADS;
8166     if (PyErr_Occurred()) return NULL;
8167 }    _resultobj = Py_BuildValue("i",_result);
8168     return _resultobj;
8169 }
8170
8171 #define wxGrid_IsCellEditControlShown(_swigobj)  (_swigobj->IsCellEditControlShown())
8172 static PyObject *_wrap_wxGrid_IsCellEditControlShown(PyObject *self, PyObject *args, PyObject *kwargs) {
8173     PyObject * _resultobj;
8174     bool  _result;
8175     wxGrid * _arg0;
8176     PyObject * _argo0 = 0;
8177     char *_kwnames[] = { "self", NULL };
8178
8179     self = self;
8180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlShown",_kwnames,&_argo0))
8181         return NULL;
8182     if (_argo0) {
8183         if (_argo0 == Py_None) { _arg0 = NULL; }
8184         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8185             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlShown. Expected _wxGrid_p.");
8186         return NULL;
8187         }
8188     }
8189 {
8190     wxPy_BEGIN_ALLOW_THREADS;
8191         _result = (bool )wxGrid_IsCellEditControlShown(_arg0);
8192
8193     wxPy_END_ALLOW_THREADS;
8194     if (PyErr_Occurred()) return NULL;
8195 }    _resultobj = Py_BuildValue("i",_result);
8196     return _resultobj;
8197 }
8198
8199 #define wxGrid_IsCurrentCellReadOnly(_swigobj)  (_swigobj->IsCurrentCellReadOnly())
8200 static PyObject *_wrap_wxGrid_IsCurrentCellReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
8201     PyObject * _resultobj;
8202     bool  _result;
8203     wxGrid * _arg0;
8204     PyObject * _argo0 = 0;
8205     char *_kwnames[] = { "self", NULL };
8206
8207     self = self;
8208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCurrentCellReadOnly",_kwnames,&_argo0))
8209         return NULL;
8210     if (_argo0) {
8211         if (_argo0 == Py_None) { _arg0 = NULL; }
8212         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8213             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCurrentCellReadOnly. Expected _wxGrid_p.");
8214         return NULL;
8215         }
8216     }
8217 {
8218     wxPy_BEGIN_ALLOW_THREADS;
8219         _result = (bool )wxGrid_IsCurrentCellReadOnly(_arg0);
8220
8221     wxPy_END_ALLOW_THREADS;
8222     if (PyErr_Occurred()) return NULL;
8223 }    _resultobj = Py_BuildValue("i",_result);
8224     return _resultobj;
8225 }
8226
8227 #define wxGrid_ShowCellEditControl(_swigobj)  (_swigobj->ShowCellEditControl())
8228 static PyObject *_wrap_wxGrid_ShowCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8229     PyObject * _resultobj;
8230     wxGrid * _arg0;
8231     PyObject * _argo0 = 0;
8232     char *_kwnames[] = { "self", NULL };
8233
8234     self = self;
8235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ShowCellEditControl",_kwnames,&_argo0))
8236         return NULL;
8237     if (_argo0) {
8238         if (_argo0 == Py_None) { _arg0 = NULL; }
8239         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8240             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ShowCellEditControl. Expected _wxGrid_p.");
8241         return NULL;
8242         }
8243     }
8244 {
8245     wxPy_BEGIN_ALLOW_THREADS;
8246         wxGrid_ShowCellEditControl(_arg0);
8247
8248     wxPy_END_ALLOW_THREADS;
8249     if (PyErr_Occurred()) return NULL;
8250 }    Py_INCREF(Py_None);
8251     _resultobj = Py_None;
8252     return _resultobj;
8253 }
8254
8255 #define wxGrid_HideCellEditControl(_swigobj)  (_swigobj->HideCellEditControl())
8256 static PyObject *_wrap_wxGrid_HideCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8257     PyObject * _resultobj;
8258     wxGrid * _arg0;
8259     PyObject * _argo0 = 0;
8260     char *_kwnames[] = { "self", NULL };
8261
8262     self = self;
8263     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_HideCellEditControl",_kwnames,&_argo0))
8264         return NULL;
8265     if (_argo0) {
8266         if (_argo0 == Py_None) { _arg0 = NULL; }
8267         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8268             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_HideCellEditControl. Expected _wxGrid_p.");
8269         return NULL;
8270         }
8271     }
8272 {
8273     wxPy_BEGIN_ALLOW_THREADS;
8274         wxGrid_HideCellEditControl(_arg0);
8275
8276     wxPy_END_ALLOW_THREADS;
8277     if (PyErr_Occurred()) return NULL;
8278 }    Py_INCREF(Py_None);
8279     _resultobj = Py_None;
8280     return _resultobj;
8281 }
8282
8283 #define wxGrid_SaveEditControlValue(_swigobj)  (_swigobj->SaveEditControlValue())
8284 static PyObject *_wrap_wxGrid_SaveEditControlValue(PyObject *self, PyObject *args, PyObject *kwargs) {
8285     PyObject * _resultobj;
8286     wxGrid * _arg0;
8287     PyObject * _argo0 = 0;
8288     char *_kwnames[] = { "self", NULL };
8289
8290     self = self;
8291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SaveEditControlValue",_kwnames,&_argo0))
8292         return NULL;
8293     if (_argo0) {
8294         if (_argo0 == Py_None) { _arg0 = NULL; }
8295         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8296             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SaveEditControlValue. Expected _wxGrid_p.");
8297         return NULL;
8298         }
8299     }
8300 {
8301     wxPy_BEGIN_ALLOW_THREADS;
8302         wxGrid_SaveEditControlValue(_arg0);
8303
8304     wxPy_END_ALLOW_THREADS;
8305     if (PyErr_Occurred()) return NULL;
8306 }    Py_INCREF(Py_None);
8307     _resultobj = Py_None;
8308     return _resultobj;
8309 }
8310
8311 static wxGridCellCoords * wxGrid_XYToCell(wxGrid *self,int  x,int  y) {
8312             wxGridCellCoords rv;
8313             self->XYToCell(x, y, rv);
8314             return new wxGridCellCoords(rv);
8315         }
8316 static PyObject *_wrap_wxGrid_XYToCell(PyObject *self, PyObject *args, PyObject *kwargs) {
8317     PyObject * _resultobj;
8318     wxGridCellCoords * _result;
8319     wxGrid * _arg0;
8320     int  _arg1;
8321     int  _arg2;
8322     PyObject * _argo0 = 0;
8323     char *_kwnames[] = { "self","x","y", NULL };
8324     char _ptemp[128];
8325
8326     self = self;
8327     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_XYToCell",_kwnames,&_argo0,&_arg1,&_arg2))
8328         return NULL;
8329     if (_argo0) {
8330         if (_argo0 == Py_None) { _arg0 = NULL; }
8331         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8332             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XYToCell. Expected _wxGrid_p.");
8333         return NULL;
8334         }
8335     }
8336 {
8337     wxPy_BEGIN_ALLOW_THREADS;
8338         _result = (wxGridCellCoords *)wxGrid_XYToCell(_arg0,_arg1,_arg2);
8339
8340     wxPy_END_ALLOW_THREADS;
8341     if (PyErr_Occurred()) return NULL;
8342 }    if (_result) {
8343         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
8344         _resultobj = Py_BuildValue("s",_ptemp);
8345     } else {
8346         Py_INCREF(Py_None);
8347         _resultobj = Py_None;
8348     }
8349     return _resultobj;
8350 }
8351
8352 #define wxGrid_YToRow(_swigobj,_swigarg0)  (_swigobj->YToRow(_swigarg0))
8353 static PyObject *_wrap_wxGrid_YToRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8354     PyObject * _resultobj;
8355     int  _result;
8356     wxGrid * _arg0;
8357     int  _arg1;
8358     PyObject * _argo0 = 0;
8359     char *_kwnames[] = { "self","y", NULL };
8360
8361     self = self;
8362     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToRow",_kwnames,&_argo0,&_arg1))
8363         return NULL;
8364     if (_argo0) {
8365         if (_argo0 == Py_None) { _arg0 = NULL; }
8366         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8367             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToRow. Expected _wxGrid_p.");
8368         return NULL;
8369         }
8370     }
8371 {
8372     wxPy_BEGIN_ALLOW_THREADS;
8373         _result = (int )wxGrid_YToRow(_arg0,_arg1);
8374
8375     wxPy_END_ALLOW_THREADS;
8376     if (PyErr_Occurred()) return NULL;
8377 }    _resultobj = Py_BuildValue("i",_result);
8378     return _resultobj;
8379 }
8380
8381 #define wxGrid_XToCol(_swigobj,_swigarg0)  (_swigobj->XToCol(_swigarg0))
8382 static PyObject *_wrap_wxGrid_XToCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8383     PyObject * _resultobj;
8384     int  _result;
8385     wxGrid * _arg0;
8386     int  _arg1;
8387     PyObject * _argo0 = 0;
8388     char *_kwnames[] = { "self","x", NULL };
8389
8390     self = self;
8391     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToCol",_kwnames,&_argo0,&_arg1))
8392         return NULL;
8393     if (_argo0) {
8394         if (_argo0 == Py_None) { _arg0 = NULL; }
8395         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8396             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToCol. Expected _wxGrid_p.");
8397         return NULL;
8398         }
8399     }
8400 {
8401     wxPy_BEGIN_ALLOW_THREADS;
8402         _result = (int )wxGrid_XToCol(_arg0,_arg1);
8403
8404     wxPy_END_ALLOW_THREADS;
8405     if (PyErr_Occurred()) return NULL;
8406 }    _resultobj = Py_BuildValue("i",_result);
8407     return _resultobj;
8408 }
8409
8410 #define wxGrid_YToEdgeOfRow(_swigobj,_swigarg0)  (_swigobj->YToEdgeOfRow(_swigarg0))
8411 static PyObject *_wrap_wxGrid_YToEdgeOfRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8412     PyObject * _resultobj;
8413     int  _result;
8414     wxGrid * _arg0;
8415     int  _arg1;
8416     PyObject * _argo0 = 0;
8417     char *_kwnames[] = { "self","y", NULL };
8418
8419     self = self;
8420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToEdgeOfRow",_kwnames,&_argo0,&_arg1))
8421         return NULL;
8422     if (_argo0) {
8423         if (_argo0 == Py_None) { _arg0 = NULL; }
8424         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8425             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToEdgeOfRow. Expected _wxGrid_p.");
8426         return NULL;
8427         }
8428     }
8429 {
8430     wxPy_BEGIN_ALLOW_THREADS;
8431         _result = (int )wxGrid_YToEdgeOfRow(_arg0,_arg1);
8432
8433     wxPy_END_ALLOW_THREADS;
8434     if (PyErr_Occurred()) return NULL;
8435 }    _resultobj = Py_BuildValue("i",_result);
8436     return _resultobj;
8437 }
8438
8439 #define wxGrid_XToEdgeOfCol(_swigobj,_swigarg0)  (_swigobj->XToEdgeOfCol(_swigarg0))
8440 static PyObject *_wrap_wxGrid_XToEdgeOfCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8441     PyObject * _resultobj;
8442     int  _result;
8443     wxGrid * _arg0;
8444     int  _arg1;
8445     PyObject * _argo0 = 0;
8446     char *_kwnames[] = { "self","x", NULL };
8447
8448     self = self;
8449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToEdgeOfCol",_kwnames,&_argo0,&_arg1))
8450         return NULL;
8451     if (_argo0) {
8452         if (_argo0 == Py_None) { _arg0 = NULL; }
8453         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8454             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToEdgeOfCol. Expected _wxGrid_p.");
8455         return NULL;
8456         }
8457     }
8458 {
8459     wxPy_BEGIN_ALLOW_THREADS;
8460         _result = (int )wxGrid_XToEdgeOfCol(_arg0,_arg1);
8461
8462     wxPy_END_ALLOW_THREADS;
8463     if (PyErr_Occurred()) return NULL;
8464 }    _resultobj = Py_BuildValue("i",_result);
8465     return _resultobj;
8466 }
8467
8468 #define wxGrid_CellToRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->CellToRect(_swigarg0,_swigarg1))
8469 static PyObject *_wrap_wxGrid_CellToRect(PyObject *self, PyObject *args, PyObject *kwargs) {
8470     PyObject * _resultobj;
8471     wxRect * _result;
8472     wxGrid * _arg0;
8473     int  _arg1;
8474     int  _arg2;
8475     PyObject * _argo0 = 0;
8476     char *_kwnames[] = { "self","row","col", NULL };
8477     char _ptemp[128];
8478
8479     self = self;
8480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_CellToRect",_kwnames,&_argo0,&_arg1,&_arg2))
8481         return NULL;
8482     if (_argo0) {
8483         if (_argo0 == Py_None) { _arg0 = NULL; }
8484         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8485             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CellToRect. Expected _wxGrid_p.");
8486         return NULL;
8487         }
8488     }
8489 {
8490     wxPy_BEGIN_ALLOW_THREADS;
8491         _result = new wxRect (wxGrid_CellToRect(_arg0,_arg1,_arg2));
8492
8493     wxPy_END_ALLOW_THREADS;
8494     if (PyErr_Occurred()) return NULL;
8495 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
8496     _resultobj = Py_BuildValue("s",_ptemp);
8497     return _resultobj;
8498 }
8499
8500 #define wxGrid_GetGridCursorRow(_swigobj)  (_swigobj->GetGridCursorRow())
8501 static PyObject *_wrap_wxGrid_GetGridCursorRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8502     PyObject * _resultobj;
8503     int  _result;
8504     wxGrid * _arg0;
8505     PyObject * _argo0 = 0;
8506     char *_kwnames[] = { "self", NULL };
8507
8508     self = self;
8509     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorRow",_kwnames,&_argo0))
8510         return NULL;
8511     if (_argo0) {
8512         if (_argo0 == Py_None) { _arg0 = NULL; }
8513         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8514             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorRow. Expected _wxGrid_p.");
8515         return NULL;
8516         }
8517     }
8518 {
8519     wxPy_BEGIN_ALLOW_THREADS;
8520         _result = (int )wxGrid_GetGridCursorRow(_arg0);
8521
8522     wxPy_END_ALLOW_THREADS;
8523     if (PyErr_Occurred()) return NULL;
8524 }    _resultobj = Py_BuildValue("i",_result);
8525     return _resultobj;
8526 }
8527
8528 #define wxGrid_GetGridCursorCol(_swigobj)  (_swigobj->GetGridCursorCol())
8529 static PyObject *_wrap_wxGrid_GetGridCursorCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8530     PyObject * _resultobj;
8531     int  _result;
8532     wxGrid * _arg0;
8533     PyObject * _argo0 = 0;
8534     char *_kwnames[] = { "self", NULL };
8535
8536     self = self;
8537     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorCol",_kwnames,&_argo0))
8538         return NULL;
8539     if (_argo0) {
8540         if (_argo0 == Py_None) { _arg0 = NULL; }
8541         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8542             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorCol. Expected _wxGrid_p.");
8543         return NULL;
8544         }
8545     }
8546 {
8547     wxPy_BEGIN_ALLOW_THREADS;
8548         _result = (int )wxGrid_GetGridCursorCol(_arg0);
8549
8550     wxPy_END_ALLOW_THREADS;
8551     if (PyErr_Occurred()) return NULL;
8552 }    _resultobj = Py_BuildValue("i",_result);
8553     return _resultobj;
8554 }
8555
8556 #define wxGrid_IsVisible(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->IsVisible(_swigarg0,_swigarg1,_swigarg2))
8557 static PyObject *_wrap_wxGrid_IsVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8558     PyObject * _resultobj;
8559     bool  _result;
8560     wxGrid * _arg0;
8561     int  _arg1;
8562     int  _arg2;
8563     bool  _arg3 = (bool ) TRUE;
8564     PyObject * _argo0 = 0;
8565     int tempbool3 = (int) TRUE;
8566     char *_kwnames[] = { "self","row","col","wholeCellVisible", NULL };
8567
8568     self = self;
8569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_IsVisible",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
8570         return NULL;
8571     if (_argo0) {
8572         if (_argo0 == Py_None) { _arg0 = NULL; }
8573         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8574             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsVisible. Expected _wxGrid_p.");
8575         return NULL;
8576         }
8577     }
8578     _arg3 = (bool ) tempbool3;
8579 {
8580     wxPy_BEGIN_ALLOW_THREADS;
8581         _result = (bool )wxGrid_IsVisible(_arg0,_arg1,_arg2,_arg3);
8582
8583     wxPy_END_ALLOW_THREADS;
8584     if (PyErr_Occurred()) return NULL;
8585 }    _resultobj = Py_BuildValue("i",_result);
8586     return _resultobj;
8587 }
8588
8589 #define wxGrid_MakeCellVisible(_swigobj,_swigarg0,_swigarg1)  (_swigobj->MakeCellVisible(_swigarg0,_swigarg1))
8590 static PyObject *_wrap_wxGrid_MakeCellVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8591     PyObject * _resultobj;
8592     wxGrid * _arg0;
8593     int  _arg1;
8594     int  _arg2;
8595     PyObject * _argo0 = 0;
8596     char *_kwnames[] = { "self","row","col", NULL };
8597
8598     self = self;
8599     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_MakeCellVisible",_kwnames,&_argo0,&_arg1,&_arg2))
8600         return NULL;
8601     if (_argo0) {
8602         if (_argo0 == Py_None) { _arg0 = NULL; }
8603         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8604             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MakeCellVisible. Expected _wxGrid_p.");
8605         return NULL;
8606         }
8607     }
8608 {
8609     wxPy_BEGIN_ALLOW_THREADS;
8610         wxGrid_MakeCellVisible(_arg0,_arg1,_arg2);
8611
8612     wxPy_END_ALLOW_THREADS;
8613     if (PyErr_Occurred()) return NULL;
8614 }    Py_INCREF(Py_None);
8615     _resultobj = Py_None;
8616     return _resultobj;
8617 }
8618
8619 #define wxGrid_SetGridCursor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetGridCursor(_swigarg0,_swigarg1))
8620 static PyObject *_wrap_wxGrid_SetGridCursor(PyObject *self, PyObject *args, PyObject *kwargs) {
8621     PyObject * _resultobj;
8622     wxGrid * _arg0;
8623     int  _arg1;
8624     int  _arg2;
8625     PyObject * _argo0 = 0;
8626     char *_kwnames[] = { "self","row","col", NULL };
8627
8628     self = self;
8629     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetGridCursor",_kwnames,&_argo0,&_arg1,&_arg2))
8630         return NULL;
8631     if (_argo0) {
8632         if (_argo0 == Py_None) { _arg0 = NULL; }
8633         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8634             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridCursor. Expected _wxGrid_p.");
8635         return NULL;
8636         }
8637     }
8638 {
8639     wxPy_BEGIN_ALLOW_THREADS;
8640         wxGrid_SetGridCursor(_arg0,_arg1,_arg2);
8641
8642     wxPy_END_ALLOW_THREADS;
8643     if (PyErr_Occurred()) return NULL;
8644 }    Py_INCREF(Py_None);
8645     _resultobj = Py_None;
8646     return _resultobj;
8647 }
8648
8649 #define wxGrid_MoveCursorUp(_swigobj,_swigarg0)  (_swigobj->MoveCursorUp(_swigarg0))
8650 static PyObject *_wrap_wxGrid_MoveCursorUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8651     PyObject * _resultobj;
8652     bool  _result;
8653     wxGrid * _arg0;
8654     bool  _arg1;
8655     PyObject * _argo0 = 0;
8656     int tempbool1;
8657     char *_kwnames[] = { "self","expandSelection", NULL };
8658
8659     self = self;
8660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUp",_kwnames,&_argo0,&tempbool1))
8661         return NULL;
8662     if (_argo0) {
8663         if (_argo0 == Py_None) { _arg0 = NULL; }
8664         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8665             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUp. Expected _wxGrid_p.");
8666         return NULL;
8667         }
8668     }
8669     _arg1 = (bool ) tempbool1;
8670 {
8671     wxPy_BEGIN_ALLOW_THREADS;
8672         _result = (bool )wxGrid_MoveCursorUp(_arg0,_arg1);
8673
8674     wxPy_END_ALLOW_THREADS;
8675     if (PyErr_Occurred()) return NULL;
8676 }    _resultobj = Py_BuildValue("i",_result);
8677     return _resultobj;
8678 }
8679
8680 #define wxGrid_MoveCursorDown(_swigobj,_swigarg0)  (_swigobj->MoveCursorDown(_swigarg0))
8681 static PyObject *_wrap_wxGrid_MoveCursorDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8682     PyObject * _resultobj;
8683     bool  _result;
8684     wxGrid * _arg0;
8685     bool  _arg1;
8686     PyObject * _argo0 = 0;
8687     int tempbool1;
8688     char *_kwnames[] = { "self","expandSelection", NULL };
8689
8690     self = self;
8691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDown",_kwnames,&_argo0,&tempbool1))
8692         return NULL;
8693     if (_argo0) {
8694         if (_argo0 == Py_None) { _arg0 = NULL; }
8695         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8696             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDown. Expected _wxGrid_p.");
8697         return NULL;
8698         }
8699     }
8700     _arg1 = (bool ) tempbool1;
8701 {
8702     wxPy_BEGIN_ALLOW_THREADS;
8703         _result = (bool )wxGrid_MoveCursorDown(_arg0,_arg1);
8704
8705     wxPy_END_ALLOW_THREADS;
8706     if (PyErr_Occurred()) return NULL;
8707 }    _resultobj = Py_BuildValue("i",_result);
8708     return _resultobj;
8709 }
8710
8711 #define wxGrid_MoveCursorLeft(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeft(_swigarg0))
8712 static PyObject *_wrap_wxGrid_MoveCursorLeft(PyObject *self, PyObject *args, PyObject *kwargs) {
8713     PyObject * _resultobj;
8714     bool  _result;
8715     wxGrid * _arg0;
8716     bool  _arg1;
8717     PyObject * _argo0 = 0;
8718     int tempbool1;
8719     char *_kwnames[] = { "self","expandSelection", NULL };
8720
8721     self = self;
8722     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeft",_kwnames,&_argo0,&tempbool1))
8723         return NULL;
8724     if (_argo0) {
8725         if (_argo0 == Py_None) { _arg0 = NULL; }
8726         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8727             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeft. Expected _wxGrid_p.");
8728         return NULL;
8729         }
8730     }
8731     _arg1 = (bool ) tempbool1;
8732 {
8733     wxPy_BEGIN_ALLOW_THREADS;
8734         _result = (bool )wxGrid_MoveCursorLeft(_arg0,_arg1);
8735
8736     wxPy_END_ALLOW_THREADS;
8737     if (PyErr_Occurred()) return NULL;
8738 }    _resultobj = Py_BuildValue("i",_result);
8739     return _resultobj;
8740 }
8741
8742 #define wxGrid_MoveCursorRight(_swigobj,_swigarg0)  (_swigobj->MoveCursorRight(_swigarg0))
8743 static PyObject *_wrap_wxGrid_MoveCursorRight(PyObject *self, PyObject *args, PyObject *kwargs) {
8744     PyObject * _resultobj;
8745     bool  _result;
8746     wxGrid * _arg0;
8747     bool  _arg1;
8748     PyObject * _argo0 = 0;
8749     int tempbool1;
8750     char *_kwnames[] = { "self","expandSelection", NULL };
8751
8752     self = self;
8753     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRight",_kwnames,&_argo0,&tempbool1))
8754         return NULL;
8755     if (_argo0) {
8756         if (_argo0 == Py_None) { _arg0 = NULL; }
8757         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8758             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRight. Expected _wxGrid_p.");
8759         return NULL;
8760         }
8761     }
8762     _arg1 = (bool ) tempbool1;
8763 {
8764     wxPy_BEGIN_ALLOW_THREADS;
8765         _result = (bool )wxGrid_MoveCursorRight(_arg0,_arg1);
8766
8767     wxPy_END_ALLOW_THREADS;
8768     if (PyErr_Occurred()) return NULL;
8769 }    _resultobj = Py_BuildValue("i",_result);
8770     return _resultobj;
8771 }
8772
8773 #define wxGrid_MovePageDown(_swigobj)  (_swigobj->MovePageDown())
8774 static PyObject *_wrap_wxGrid_MovePageDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8775     PyObject * _resultobj;
8776     bool  _result;
8777     wxGrid * _arg0;
8778     PyObject * _argo0 = 0;
8779     char *_kwnames[] = { "self", NULL };
8780
8781     self = self;
8782     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageDown",_kwnames,&_argo0))
8783         return NULL;
8784     if (_argo0) {
8785         if (_argo0 == Py_None) { _arg0 = NULL; }
8786         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8787             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageDown. Expected _wxGrid_p.");
8788         return NULL;
8789         }
8790     }
8791 {
8792     wxPy_BEGIN_ALLOW_THREADS;
8793         _result = (bool )wxGrid_MovePageDown(_arg0);
8794
8795     wxPy_END_ALLOW_THREADS;
8796     if (PyErr_Occurred()) return NULL;
8797 }    _resultobj = Py_BuildValue("i",_result);
8798     return _resultobj;
8799 }
8800
8801 #define wxGrid_MovePageUp(_swigobj)  (_swigobj->MovePageUp())
8802 static PyObject *_wrap_wxGrid_MovePageUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8803     PyObject * _resultobj;
8804     bool  _result;
8805     wxGrid * _arg0;
8806     PyObject * _argo0 = 0;
8807     char *_kwnames[] = { "self", NULL };
8808
8809     self = self;
8810     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageUp",_kwnames,&_argo0))
8811         return NULL;
8812     if (_argo0) {
8813         if (_argo0 == Py_None) { _arg0 = NULL; }
8814         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8815             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageUp. Expected _wxGrid_p.");
8816         return NULL;
8817         }
8818     }
8819 {
8820     wxPy_BEGIN_ALLOW_THREADS;
8821         _result = (bool )wxGrid_MovePageUp(_arg0);
8822
8823     wxPy_END_ALLOW_THREADS;
8824     if (PyErr_Occurred()) return NULL;
8825 }    _resultobj = Py_BuildValue("i",_result);
8826     return _resultobj;
8827 }
8828
8829 #define wxGrid_MoveCursorUpBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorUpBlock(_swigarg0))
8830 static PyObject *_wrap_wxGrid_MoveCursorUpBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8831     PyObject * _resultobj;
8832     bool  _result;
8833     wxGrid * _arg0;
8834     bool  _arg1;
8835     PyObject * _argo0 = 0;
8836     int tempbool1;
8837     char *_kwnames[] = { "self","expandSelection", NULL };
8838
8839     self = self;
8840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUpBlock",_kwnames,&_argo0,&tempbool1))
8841         return NULL;
8842     if (_argo0) {
8843         if (_argo0 == Py_None) { _arg0 = NULL; }
8844         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8845             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUpBlock. Expected _wxGrid_p.");
8846         return NULL;
8847         }
8848     }
8849     _arg1 = (bool ) tempbool1;
8850 {
8851     wxPy_BEGIN_ALLOW_THREADS;
8852         _result = (bool )wxGrid_MoveCursorUpBlock(_arg0,_arg1);
8853
8854     wxPy_END_ALLOW_THREADS;
8855     if (PyErr_Occurred()) return NULL;
8856 }    _resultobj = Py_BuildValue("i",_result);
8857     return _resultobj;
8858 }
8859
8860 #define wxGrid_MoveCursorDownBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorDownBlock(_swigarg0))
8861 static PyObject *_wrap_wxGrid_MoveCursorDownBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8862     PyObject * _resultobj;
8863     bool  _result;
8864     wxGrid * _arg0;
8865     bool  _arg1;
8866     PyObject * _argo0 = 0;
8867     int tempbool1;
8868     char *_kwnames[] = { "self","expandSelection", NULL };
8869
8870     self = self;
8871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDownBlock",_kwnames,&_argo0,&tempbool1))
8872         return NULL;
8873     if (_argo0) {
8874         if (_argo0 == Py_None) { _arg0 = NULL; }
8875         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8876             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDownBlock. Expected _wxGrid_p.");
8877         return NULL;
8878         }
8879     }
8880     _arg1 = (bool ) tempbool1;
8881 {
8882     wxPy_BEGIN_ALLOW_THREADS;
8883         _result = (bool )wxGrid_MoveCursorDownBlock(_arg0,_arg1);
8884
8885     wxPy_END_ALLOW_THREADS;
8886     if (PyErr_Occurred()) return NULL;
8887 }    _resultobj = Py_BuildValue("i",_result);
8888     return _resultobj;
8889 }
8890
8891 #define wxGrid_MoveCursorLeftBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeftBlock(_swigarg0))
8892 static PyObject *_wrap_wxGrid_MoveCursorLeftBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8893     PyObject * _resultobj;
8894     bool  _result;
8895     wxGrid * _arg0;
8896     bool  _arg1;
8897     PyObject * _argo0 = 0;
8898     int tempbool1;
8899     char *_kwnames[] = { "self","expandSelection", NULL };
8900
8901     self = self;
8902     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeftBlock",_kwnames,&_argo0,&tempbool1))
8903         return NULL;
8904     if (_argo0) {
8905         if (_argo0 == Py_None) { _arg0 = NULL; }
8906         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8907             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeftBlock. Expected _wxGrid_p.");
8908         return NULL;
8909         }
8910     }
8911     _arg1 = (bool ) tempbool1;
8912 {
8913     wxPy_BEGIN_ALLOW_THREADS;
8914         _result = (bool )wxGrid_MoveCursorLeftBlock(_arg0,_arg1);
8915
8916     wxPy_END_ALLOW_THREADS;
8917     if (PyErr_Occurred()) return NULL;
8918 }    _resultobj = Py_BuildValue("i",_result);
8919     return _resultobj;
8920 }
8921
8922 #define wxGrid_MoveCursorRightBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorRightBlock(_swigarg0))
8923 static PyObject *_wrap_wxGrid_MoveCursorRightBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8924     PyObject * _resultobj;
8925     bool  _result;
8926     wxGrid * _arg0;
8927     bool  _arg1;
8928     PyObject * _argo0 = 0;
8929     int tempbool1;
8930     char *_kwnames[] = { "self","expandSelection", NULL };
8931
8932     self = self;
8933     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRightBlock",_kwnames,&_argo0,&tempbool1))
8934         return NULL;
8935     if (_argo0) {
8936         if (_argo0 == Py_None) { _arg0 = NULL; }
8937         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8938             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRightBlock. Expected _wxGrid_p.");
8939         return NULL;
8940         }
8941     }
8942     _arg1 = (bool ) tempbool1;
8943 {
8944     wxPy_BEGIN_ALLOW_THREADS;
8945         _result = (bool )wxGrid_MoveCursorRightBlock(_arg0,_arg1);
8946
8947     wxPy_END_ALLOW_THREADS;
8948     if (PyErr_Occurred()) return NULL;
8949 }    _resultobj = Py_BuildValue("i",_result);
8950     return _resultobj;
8951 }
8952
8953 #define wxGrid_GetDefaultRowLabelSize(_swigobj)  (_swigobj->GetDefaultRowLabelSize())
8954 static PyObject *_wrap_wxGrid_GetDefaultRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
8955     PyObject * _resultobj;
8956     int  _result;
8957     wxGrid * _arg0;
8958     PyObject * _argo0 = 0;
8959     char *_kwnames[] = { "self", NULL };
8960
8961     self = self;
8962     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowLabelSize",_kwnames,&_argo0))
8963         return NULL;
8964     if (_argo0) {
8965         if (_argo0 == Py_None) { _arg0 = NULL; }
8966         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8967             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowLabelSize. Expected _wxGrid_p.");
8968         return NULL;
8969         }
8970     }
8971 {
8972     wxPy_BEGIN_ALLOW_THREADS;
8973         _result = (int )wxGrid_GetDefaultRowLabelSize(_arg0);
8974
8975     wxPy_END_ALLOW_THREADS;
8976     if (PyErr_Occurred()) return NULL;
8977 }    _resultobj = Py_BuildValue("i",_result);
8978     return _resultobj;
8979 }
8980
8981 #define wxGrid_GetRowLabelSize(_swigobj)  (_swigobj->GetRowLabelSize())
8982 static PyObject *_wrap_wxGrid_GetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
8983     PyObject * _resultobj;
8984     int  _result;
8985     wxGrid * _arg0;
8986     PyObject * _argo0 = 0;
8987     char *_kwnames[] = { "self", NULL };
8988
8989     self = self;
8990     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelSize",_kwnames,&_argo0))
8991         return NULL;
8992     if (_argo0) {
8993         if (_argo0 == Py_None) { _arg0 = NULL; }
8994         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8995             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelSize. Expected _wxGrid_p.");
8996         return NULL;
8997         }
8998     }
8999 {
9000     wxPy_BEGIN_ALLOW_THREADS;
9001         _result = (int )wxGrid_GetRowLabelSize(_arg0);
9002
9003     wxPy_END_ALLOW_THREADS;
9004     if (PyErr_Occurred()) return NULL;
9005 }    _resultobj = Py_BuildValue("i",_result);
9006     return _resultobj;
9007 }
9008
9009 #define wxGrid_GetDefaultColLabelSize(_swigobj)  (_swigobj->GetDefaultColLabelSize())
9010 static PyObject *_wrap_wxGrid_GetDefaultColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9011     PyObject * _resultobj;
9012     int  _result;
9013     wxGrid * _arg0;
9014     PyObject * _argo0 = 0;
9015     char *_kwnames[] = { "self", NULL };
9016
9017     self = self;
9018     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColLabelSize",_kwnames,&_argo0))
9019         return NULL;
9020     if (_argo0) {
9021         if (_argo0 == Py_None) { _arg0 = NULL; }
9022         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9023             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColLabelSize. Expected _wxGrid_p.");
9024         return NULL;
9025         }
9026     }
9027 {
9028     wxPy_BEGIN_ALLOW_THREADS;
9029         _result = (int )wxGrid_GetDefaultColLabelSize(_arg0);
9030
9031     wxPy_END_ALLOW_THREADS;
9032     if (PyErr_Occurred()) return NULL;
9033 }    _resultobj = Py_BuildValue("i",_result);
9034     return _resultobj;
9035 }
9036
9037 #define wxGrid_GetColLabelSize(_swigobj)  (_swigobj->GetColLabelSize())
9038 static PyObject *_wrap_wxGrid_GetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9039     PyObject * _resultobj;
9040     int  _result;
9041     wxGrid * _arg0;
9042     PyObject * _argo0 = 0;
9043     char *_kwnames[] = { "self", NULL };
9044
9045     self = self;
9046     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelSize",_kwnames,&_argo0))
9047         return NULL;
9048     if (_argo0) {
9049         if (_argo0 == Py_None) { _arg0 = NULL; }
9050         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9051             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelSize. Expected _wxGrid_p.");
9052         return NULL;
9053         }
9054     }
9055 {
9056     wxPy_BEGIN_ALLOW_THREADS;
9057         _result = (int )wxGrid_GetColLabelSize(_arg0);
9058
9059     wxPy_END_ALLOW_THREADS;
9060     if (PyErr_Occurred()) return NULL;
9061 }    _resultobj = Py_BuildValue("i",_result);
9062     return _resultobj;
9063 }
9064
9065 #define wxGrid_GetLabelBackgroundColour(_swigobj)  (_swigobj->GetLabelBackgroundColour())
9066 static PyObject *_wrap_wxGrid_GetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9067     PyObject * _resultobj;
9068     wxColour * _result;
9069     wxGrid * _arg0;
9070     PyObject * _argo0 = 0;
9071     char *_kwnames[] = { "self", NULL };
9072     char _ptemp[128];
9073
9074     self = self;
9075     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelBackgroundColour",_kwnames,&_argo0))
9076         return NULL;
9077     if (_argo0) {
9078         if (_argo0 == Py_None) { _arg0 = NULL; }
9079         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9080             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelBackgroundColour. Expected _wxGrid_p.");
9081         return NULL;
9082         }
9083     }
9084 {
9085     wxPy_BEGIN_ALLOW_THREADS;
9086         _result = new wxColour (wxGrid_GetLabelBackgroundColour(_arg0));
9087
9088     wxPy_END_ALLOW_THREADS;
9089     if (PyErr_Occurred()) return NULL;
9090 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9091     _resultobj = Py_BuildValue("s",_ptemp);
9092     return _resultobj;
9093 }
9094
9095 #define wxGrid_GetLabelTextColour(_swigobj)  (_swigobj->GetLabelTextColour())
9096 static PyObject *_wrap_wxGrid_GetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9097     PyObject * _resultobj;
9098     wxColour * _result;
9099     wxGrid * _arg0;
9100     PyObject * _argo0 = 0;
9101     char *_kwnames[] = { "self", NULL };
9102     char _ptemp[128];
9103
9104     self = self;
9105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelTextColour",_kwnames,&_argo0))
9106         return NULL;
9107     if (_argo0) {
9108         if (_argo0 == Py_None) { _arg0 = NULL; }
9109         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9110             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelTextColour. Expected _wxGrid_p.");
9111         return NULL;
9112         }
9113     }
9114 {
9115     wxPy_BEGIN_ALLOW_THREADS;
9116         _result = new wxColour (wxGrid_GetLabelTextColour(_arg0));
9117
9118     wxPy_END_ALLOW_THREADS;
9119     if (PyErr_Occurred()) return NULL;
9120 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9121     _resultobj = Py_BuildValue("s",_ptemp);
9122     return _resultobj;
9123 }
9124
9125 #define wxGrid_GetLabelFont(_swigobj)  (_swigobj->GetLabelFont())
9126 static PyObject *_wrap_wxGrid_GetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9127     PyObject * _resultobj;
9128     wxFont * _result;
9129     wxGrid * _arg0;
9130     PyObject * _argo0 = 0;
9131     char *_kwnames[] = { "self", NULL };
9132     char _ptemp[128];
9133
9134     self = self;
9135     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelFont",_kwnames,&_argo0))
9136         return NULL;
9137     if (_argo0) {
9138         if (_argo0 == Py_None) { _arg0 = NULL; }
9139         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9140             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelFont. Expected _wxGrid_p.");
9141         return NULL;
9142         }
9143     }
9144 {
9145     wxPy_BEGIN_ALLOW_THREADS;
9146         _result = new wxFont (wxGrid_GetLabelFont(_arg0));
9147
9148     wxPy_END_ALLOW_THREADS;
9149     if (PyErr_Occurred()) return NULL;
9150 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
9151     _resultobj = Py_BuildValue("s",_ptemp);
9152     return _resultobj;
9153 }
9154
9155 #define wxGrid_GetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRowLabelAlignment(_swigarg0,_swigarg1))
9156 static PyObject *_wrap_wxGrid_GetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9157     PyObject * _resultobj;
9158     wxGrid * _arg0;
9159     int * _arg1;
9160     int  temp;
9161     int * _arg2;
9162     int  temp0;
9163     PyObject * _argo0 = 0;
9164     char *_kwnames[] = { "self", NULL };
9165
9166     self = self;
9167 {
9168   _arg1 = &temp;
9169 }
9170 {
9171   _arg2 = &temp0;
9172 }
9173     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelAlignment",_kwnames,&_argo0))
9174         return NULL;
9175     if (_argo0) {
9176         if (_argo0 == Py_None) { _arg0 = NULL; }
9177         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9178             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelAlignment. Expected _wxGrid_p.");
9179         return NULL;
9180         }
9181     }
9182 {
9183     wxPy_BEGIN_ALLOW_THREADS;
9184         wxGrid_GetRowLabelAlignment(_arg0,_arg1,_arg2);
9185
9186     wxPy_END_ALLOW_THREADS;
9187     if (PyErr_Occurred()) return NULL;
9188 }    Py_INCREF(Py_None);
9189     _resultobj = Py_None;
9190 {
9191     PyObject *o;
9192     o = PyInt_FromLong((long) (*_arg1));
9193     _resultobj = t_output_helper(_resultobj, o);
9194 }
9195 {
9196     PyObject *o;
9197     o = PyInt_FromLong((long) (*_arg2));
9198     _resultobj = t_output_helper(_resultobj, o);
9199 }
9200     return _resultobj;
9201 }
9202
9203 #define wxGrid_GetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetColLabelAlignment(_swigarg0,_swigarg1))
9204 static PyObject *_wrap_wxGrid_GetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9205     PyObject * _resultobj;
9206     wxGrid * _arg0;
9207     int * _arg1;
9208     int  temp;
9209     int * _arg2;
9210     int  temp0;
9211     PyObject * _argo0 = 0;
9212     char *_kwnames[] = { "self", NULL };
9213
9214     self = self;
9215 {
9216   _arg1 = &temp;
9217 }
9218 {
9219   _arg2 = &temp0;
9220 }
9221     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelAlignment",_kwnames,&_argo0))
9222         return NULL;
9223     if (_argo0) {
9224         if (_argo0 == Py_None) { _arg0 = NULL; }
9225         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9226             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelAlignment. Expected _wxGrid_p.");
9227         return NULL;
9228         }
9229     }
9230 {
9231     wxPy_BEGIN_ALLOW_THREADS;
9232         wxGrid_GetColLabelAlignment(_arg0,_arg1,_arg2);
9233
9234     wxPy_END_ALLOW_THREADS;
9235     if (PyErr_Occurred()) return NULL;
9236 }    Py_INCREF(Py_None);
9237     _resultobj = Py_None;
9238 {
9239     PyObject *o;
9240     o = PyInt_FromLong((long) (*_arg1));
9241     _resultobj = t_output_helper(_resultobj, o);
9242 }
9243 {
9244     PyObject *o;
9245     o = PyInt_FromLong((long) (*_arg2));
9246     _resultobj = t_output_helper(_resultobj, o);
9247 }
9248     return _resultobj;
9249 }
9250
9251 #define wxGrid_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->GetRowLabelValue(_swigarg0))
9252 static PyObject *_wrap_wxGrid_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9253     PyObject * _resultobj;
9254     wxString * _result;
9255     wxGrid * _arg0;
9256     int  _arg1;
9257     PyObject * _argo0 = 0;
9258     char *_kwnames[] = { "self","row", NULL };
9259
9260     self = self;
9261     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
9262         return NULL;
9263     if (_argo0) {
9264         if (_argo0 == Py_None) { _arg0 = NULL; }
9265         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9266             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelValue. Expected _wxGrid_p.");
9267         return NULL;
9268         }
9269     }
9270 {
9271     wxPy_BEGIN_ALLOW_THREADS;
9272         _result = new wxString (wxGrid_GetRowLabelValue(_arg0,_arg1));
9273
9274     wxPy_END_ALLOW_THREADS;
9275     if (PyErr_Occurred()) return NULL;
9276 }{
9277     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9278 }
9279 {
9280     delete _result;
9281 }
9282     return _resultobj;
9283 }
9284
9285 #define wxGrid_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->GetColLabelValue(_swigarg0))
9286 static PyObject *_wrap_wxGrid_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9287     PyObject * _resultobj;
9288     wxString * _result;
9289     wxGrid * _arg0;
9290     int  _arg1;
9291     PyObject * _argo0 = 0;
9292     char *_kwnames[] = { "self","col", NULL };
9293
9294     self = self;
9295     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColLabelValue",_kwnames,&_argo0,&_arg1))
9296         return NULL;
9297     if (_argo0) {
9298         if (_argo0 == Py_None) { _arg0 = NULL; }
9299         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9300             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelValue. Expected _wxGrid_p.");
9301         return NULL;
9302         }
9303     }
9304 {
9305     wxPy_BEGIN_ALLOW_THREADS;
9306         _result = new wxString (wxGrid_GetColLabelValue(_arg0,_arg1));
9307
9308     wxPy_END_ALLOW_THREADS;
9309     if (PyErr_Occurred()) return NULL;
9310 }{
9311     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9312 }
9313 {
9314     delete _result;
9315 }
9316     return _resultobj;
9317 }
9318
9319 #define wxGrid_GetGridLineColour(_swigobj)  (_swigobj->GetGridLineColour())
9320 static PyObject *_wrap_wxGrid_GetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9321     PyObject * _resultobj;
9322     wxColour * _result;
9323     wxGrid * _arg0;
9324     PyObject * _argo0 = 0;
9325     char *_kwnames[] = { "self", NULL };
9326     char _ptemp[128];
9327
9328     self = self;
9329     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridLineColour",_kwnames,&_argo0))
9330         return NULL;
9331     if (_argo0) {
9332         if (_argo0 == Py_None) { _arg0 = NULL; }
9333         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9334             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridLineColour. Expected _wxGrid_p.");
9335         return NULL;
9336         }
9337     }
9338 {
9339     wxPy_BEGIN_ALLOW_THREADS;
9340         _result = new wxColour (wxGrid_GetGridLineColour(_arg0));
9341
9342     wxPy_END_ALLOW_THREADS;
9343     if (PyErr_Occurred()) return NULL;
9344 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9345     _resultobj = Py_BuildValue("s",_ptemp);
9346     return _resultobj;
9347 }
9348
9349 #define wxGrid_GetCellHighlightColour(_swigobj)  (_swigobj->GetCellHighlightColour())
9350 static PyObject *_wrap_wxGrid_GetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9351     PyObject * _resultobj;
9352     wxColour * _result;
9353     wxGrid * _arg0;
9354     PyObject * _argo0 = 0;
9355     char *_kwnames[] = { "self", NULL };
9356     char _ptemp[128];
9357
9358     self = self;
9359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightColour",_kwnames,&_argo0))
9360         return NULL;
9361     if (_argo0) {
9362         if (_argo0 == Py_None) { _arg0 = NULL; }
9363         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9364             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightColour. Expected _wxGrid_p.");
9365         return NULL;
9366         }
9367     }
9368 {
9369     wxPy_BEGIN_ALLOW_THREADS;
9370         _result = new wxColour (wxGrid_GetCellHighlightColour(_arg0));
9371
9372     wxPy_END_ALLOW_THREADS;
9373     if (PyErr_Occurred()) return NULL;
9374 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9375     _resultobj = Py_BuildValue("s",_ptemp);
9376     return _resultobj;
9377 }
9378
9379 #define wxGrid_GetCellHighlightPenWidth(_swigobj)  (_swigobj->GetCellHighlightPenWidth())
9380 static PyObject *_wrap_wxGrid_GetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9381     PyObject * _resultobj;
9382     int  _result;
9383     wxGrid * _arg0;
9384     PyObject * _argo0 = 0;
9385     char *_kwnames[] = { "self", NULL };
9386
9387     self = self;
9388     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightPenWidth",_kwnames,&_argo0))
9389         return NULL;
9390     if (_argo0) {
9391         if (_argo0 == Py_None) { _arg0 = NULL; }
9392         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9393             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightPenWidth. Expected _wxGrid_p.");
9394         return NULL;
9395         }
9396     }
9397 {
9398     wxPy_BEGIN_ALLOW_THREADS;
9399         _result = (int )wxGrid_GetCellHighlightPenWidth(_arg0);
9400
9401     wxPy_END_ALLOW_THREADS;
9402     if (PyErr_Occurred()) return NULL;
9403 }    _resultobj = Py_BuildValue("i",_result);
9404     return _resultobj;
9405 }
9406
9407 #define wxGrid_GetCellHighlightROPenWidth(_swigobj)  (_swigobj->GetCellHighlightROPenWidth())
9408 static PyObject *_wrap_wxGrid_GetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9409     PyObject * _resultobj;
9410     int  _result;
9411     wxGrid * _arg0;
9412     PyObject * _argo0 = 0;
9413     char *_kwnames[] = { "self", NULL };
9414
9415     self = self;
9416     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightROPenWidth",_kwnames,&_argo0))
9417         return NULL;
9418     if (_argo0) {
9419         if (_argo0 == Py_None) { _arg0 = NULL; }
9420         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9421             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightROPenWidth. Expected _wxGrid_p.");
9422         return NULL;
9423         }
9424     }
9425 {
9426     wxPy_BEGIN_ALLOW_THREADS;
9427         _result = (int )wxGrid_GetCellHighlightROPenWidth(_arg0);
9428
9429     wxPy_END_ALLOW_THREADS;
9430     if (PyErr_Occurred()) return NULL;
9431 }    _resultobj = Py_BuildValue("i",_result);
9432     return _resultobj;
9433 }
9434
9435 #define wxGrid_SetRowLabelSize(_swigobj,_swigarg0)  (_swigobj->SetRowLabelSize(_swigarg0))
9436 static PyObject *_wrap_wxGrid_SetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9437     PyObject * _resultobj;
9438     wxGrid * _arg0;
9439     int  _arg1;
9440     PyObject * _argo0 = 0;
9441     char *_kwnames[] = { "self","width", NULL };
9442
9443     self = self;
9444     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetRowLabelSize",_kwnames,&_argo0,&_arg1))
9445         return NULL;
9446     if (_argo0) {
9447         if (_argo0 == Py_None) { _arg0 = NULL; }
9448         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9449             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelSize. Expected _wxGrid_p.");
9450         return NULL;
9451         }
9452     }
9453 {
9454     wxPy_BEGIN_ALLOW_THREADS;
9455         wxGrid_SetRowLabelSize(_arg0,_arg1);
9456
9457     wxPy_END_ALLOW_THREADS;
9458     if (PyErr_Occurred()) return NULL;
9459 }    Py_INCREF(Py_None);
9460     _resultobj = Py_None;
9461     return _resultobj;
9462 }
9463
9464 #define wxGrid_SetColLabelSize(_swigobj,_swigarg0)  (_swigobj->SetColLabelSize(_swigarg0))
9465 static PyObject *_wrap_wxGrid_SetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9466     PyObject * _resultobj;
9467     wxGrid * _arg0;
9468     int  _arg1;
9469     PyObject * _argo0 = 0;
9470     char *_kwnames[] = { "self","height", NULL };
9471
9472     self = self;
9473     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColLabelSize",_kwnames,&_argo0,&_arg1))
9474         return NULL;
9475     if (_argo0) {
9476         if (_argo0 == Py_None) { _arg0 = NULL; }
9477         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9478             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelSize. Expected _wxGrid_p.");
9479         return NULL;
9480         }
9481     }
9482 {
9483     wxPy_BEGIN_ALLOW_THREADS;
9484         wxGrid_SetColLabelSize(_arg0,_arg1);
9485
9486     wxPy_END_ALLOW_THREADS;
9487     if (PyErr_Occurred()) return NULL;
9488 }    Py_INCREF(Py_None);
9489     _resultobj = Py_None;
9490     return _resultobj;
9491 }
9492
9493 #define wxGrid_SetLabelBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetLabelBackgroundColour(_swigarg0))
9494 static PyObject *_wrap_wxGrid_SetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9495     PyObject * _resultobj;
9496     wxGrid * _arg0;
9497     wxColour * _arg1;
9498     PyObject * _argo0 = 0;
9499     wxColour  temp;
9500     PyObject * _obj1 = 0;
9501     char *_kwnames[] = { "self","arg2", NULL };
9502
9503     self = self;
9504     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelBackgroundColour",_kwnames,&_argo0,&_obj1))
9505         return NULL;
9506     if (_argo0) {
9507         if (_argo0 == Py_None) { _arg0 = NULL; }
9508         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9509             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelBackgroundColour. Expected _wxGrid_p.");
9510         return NULL;
9511         }
9512     }
9513 {
9514     _arg1 = &temp;
9515     if (! wxColour_helper(_obj1, &_arg1))
9516         return NULL;
9517 }
9518 {
9519     wxPy_BEGIN_ALLOW_THREADS;
9520         wxGrid_SetLabelBackgroundColour(_arg0,*_arg1);
9521
9522     wxPy_END_ALLOW_THREADS;
9523     if (PyErr_Occurred()) return NULL;
9524 }    Py_INCREF(Py_None);
9525     _resultobj = Py_None;
9526     return _resultobj;
9527 }
9528
9529 #define wxGrid_SetLabelTextColour(_swigobj,_swigarg0)  (_swigobj->SetLabelTextColour(_swigarg0))
9530 static PyObject *_wrap_wxGrid_SetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9531     PyObject * _resultobj;
9532     wxGrid * _arg0;
9533     wxColour * _arg1;
9534     PyObject * _argo0 = 0;
9535     wxColour  temp;
9536     PyObject * _obj1 = 0;
9537     char *_kwnames[] = { "self","arg2", NULL };
9538
9539     self = self;
9540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelTextColour",_kwnames,&_argo0,&_obj1))
9541         return NULL;
9542     if (_argo0) {
9543         if (_argo0 == Py_None) { _arg0 = NULL; }
9544         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9545             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelTextColour. Expected _wxGrid_p.");
9546         return NULL;
9547         }
9548     }
9549 {
9550     _arg1 = &temp;
9551     if (! wxColour_helper(_obj1, &_arg1))
9552         return NULL;
9553 }
9554 {
9555     wxPy_BEGIN_ALLOW_THREADS;
9556         wxGrid_SetLabelTextColour(_arg0,*_arg1);
9557
9558     wxPy_END_ALLOW_THREADS;
9559     if (PyErr_Occurred()) return NULL;
9560 }    Py_INCREF(Py_None);
9561     _resultobj = Py_None;
9562     return _resultobj;
9563 }
9564
9565 #define wxGrid_SetLabelFont(_swigobj,_swigarg0)  (_swigobj->SetLabelFont(_swigarg0))
9566 static PyObject *_wrap_wxGrid_SetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9567     PyObject * _resultobj;
9568     wxGrid * _arg0;
9569     wxFont * _arg1;
9570     PyObject * _argo0 = 0;
9571     PyObject * _argo1 = 0;
9572     char *_kwnames[] = { "self","arg2", NULL };
9573
9574     self = self;
9575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelFont",_kwnames,&_argo0,&_argo1))
9576         return NULL;
9577     if (_argo0) {
9578         if (_argo0 == Py_None) { _arg0 = NULL; }
9579         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9580             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelFont. Expected _wxGrid_p.");
9581         return NULL;
9582         }
9583     }
9584     if (_argo1) {
9585         if (_argo1 == Py_None) { _arg1 = NULL; }
9586         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
9587             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetLabelFont. Expected _wxFont_p.");
9588         return NULL;
9589         }
9590     }
9591 {
9592     wxPy_BEGIN_ALLOW_THREADS;
9593         wxGrid_SetLabelFont(_arg0,*_arg1);
9594
9595     wxPy_END_ALLOW_THREADS;
9596     if (PyErr_Occurred()) return NULL;
9597 }    Py_INCREF(Py_None);
9598     _resultobj = Py_None;
9599     return _resultobj;
9600 }
9601
9602 #define wxGrid_SetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelAlignment(_swigarg0,_swigarg1))
9603 static PyObject *_wrap_wxGrid_SetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9604     PyObject * _resultobj;
9605     wxGrid * _arg0;
9606     int  _arg1;
9607     int  _arg2;
9608     PyObject * _argo0 = 0;
9609     char *_kwnames[] = { "self","horiz","vert", NULL };
9610
9611     self = self;
9612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9613         return NULL;
9614     if (_argo0) {
9615         if (_argo0 == Py_None) { _arg0 = NULL; }
9616         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9617             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelAlignment. Expected _wxGrid_p.");
9618         return NULL;
9619         }
9620     }
9621 {
9622     wxPy_BEGIN_ALLOW_THREADS;
9623         wxGrid_SetRowLabelAlignment(_arg0,_arg1,_arg2);
9624
9625     wxPy_END_ALLOW_THREADS;
9626     if (PyErr_Occurred()) return NULL;
9627 }    Py_INCREF(Py_None);
9628     _resultobj = Py_None;
9629     return _resultobj;
9630 }
9631
9632 #define wxGrid_SetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelAlignment(_swigarg0,_swigarg1))
9633 static PyObject *_wrap_wxGrid_SetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9634     PyObject * _resultobj;
9635     wxGrid * _arg0;
9636     int  _arg1;
9637     int  _arg2;
9638     PyObject * _argo0 = 0;
9639     char *_kwnames[] = { "self","horiz","vert", NULL };
9640
9641     self = self;
9642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9643         return NULL;
9644     if (_argo0) {
9645         if (_argo0 == Py_None) { _arg0 = NULL; }
9646         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9647             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelAlignment. Expected _wxGrid_p.");
9648         return NULL;
9649         }
9650     }
9651 {
9652     wxPy_BEGIN_ALLOW_THREADS;
9653         wxGrid_SetColLabelAlignment(_arg0,_arg1,_arg2);
9654
9655     wxPy_END_ALLOW_THREADS;
9656     if (PyErr_Occurred()) return NULL;
9657 }    Py_INCREF(Py_None);
9658     _resultobj = Py_None;
9659     return _resultobj;
9660 }
9661
9662 #define wxGrid_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelValue(_swigarg0,_swigarg1))
9663 static PyObject *_wrap_wxGrid_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9664     PyObject * _resultobj;
9665     wxGrid * _arg0;
9666     int  _arg1;
9667     wxString * _arg2;
9668     PyObject * _argo0 = 0;
9669     PyObject * _obj2 = 0;
9670     char *_kwnames[] = { "self","row","arg3", NULL };
9671
9672     self = self;
9673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9674         return NULL;
9675     if (_argo0) {
9676         if (_argo0 == Py_None) { _arg0 = NULL; }
9677         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9678             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelValue. Expected _wxGrid_p.");
9679         return NULL;
9680         }
9681     }
9682 {
9683 #if PYTHON_API_VERSION >= 1009
9684     char* tmpPtr; int tmpSize;
9685     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9686         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9687         return NULL;
9688     }
9689     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9690         return NULL;
9691     _arg2 = new wxString(tmpPtr, tmpSize);
9692 #else
9693     if (!PyString_Check(_obj2)) {
9694         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9695         return NULL;
9696     }
9697     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9698 #endif
9699 }
9700 {
9701     wxPy_BEGIN_ALLOW_THREADS;
9702         wxGrid_SetRowLabelValue(_arg0,_arg1,*_arg2);
9703
9704     wxPy_END_ALLOW_THREADS;
9705     if (PyErr_Occurred()) return NULL;
9706 }    Py_INCREF(Py_None);
9707     _resultobj = Py_None;
9708 {
9709     if (_obj2)
9710         delete _arg2;
9711 }
9712     return _resultobj;
9713 }
9714
9715 #define wxGrid_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelValue(_swigarg0,_swigarg1))
9716 static PyObject *_wrap_wxGrid_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9717     PyObject * _resultobj;
9718     wxGrid * _arg0;
9719     int  _arg1;
9720     wxString * _arg2;
9721     PyObject * _argo0 = 0;
9722     PyObject * _obj2 = 0;
9723     char *_kwnames[] = { "self","col","arg3", NULL };
9724
9725     self = self;
9726     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9727         return NULL;
9728     if (_argo0) {
9729         if (_argo0 == Py_None) { _arg0 = NULL; }
9730         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9731             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelValue. Expected _wxGrid_p.");
9732         return NULL;
9733         }
9734     }
9735 {
9736 #if PYTHON_API_VERSION >= 1009
9737     char* tmpPtr; int tmpSize;
9738     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9739         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9740         return NULL;
9741     }
9742     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9743         return NULL;
9744     _arg2 = new wxString(tmpPtr, tmpSize);
9745 #else
9746     if (!PyString_Check(_obj2)) {
9747         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9748         return NULL;
9749     }
9750     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9751 #endif
9752 }
9753 {
9754     wxPy_BEGIN_ALLOW_THREADS;
9755         wxGrid_SetColLabelValue(_arg0,_arg1,*_arg2);
9756
9757     wxPy_END_ALLOW_THREADS;
9758     if (PyErr_Occurred()) return NULL;
9759 }    Py_INCREF(Py_None);
9760     _resultobj = Py_None;
9761 {
9762     if (_obj2)
9763         delete _arg2;
9764 }
9765     return _resultobj;
9766 }
9767
9768 #define wxGrid_SetGridLineColour(_swigobj,_swigarg0)  (_swigobj->SetGridLineColour(_swigarg0))
9769 static PyObject *_wrap_wxGrid_SetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9770     PyObject * _resultobj;
9771     wxGrid * _arg0;
9772     wxColour * _arg1;
9773     PyObject * _argo0 = 0;
9774     wxColour  temp;
9775     PyObject * _obj1 = 0;
9776     char *_kwnames[] = { "self","arg2", NULL };
9777
9778     self = self;
9779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetGridLineColour",_kwnames,&_argo0,&_obj1))
9780         return NULL;
9781     if (_argo0) {
9782         if (_argo0 == Py_None) { _arg0 = NULL; }
9783         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9784             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridLineColour. Expected _wxGrid_p.");
9785         return NULL;
9786         }
9787     }
9788 {
9789     _arg1 = &temp;
9790     if (! wxColour_helper(_obj1, &_arg1))
9791         return NULL;
9792 }
9793 {
9794     wxPy_BEGIN_ALLOW_THREADS;
9795         wxGrid_SetGridLineColour(_arg0,*_arg1);
9796
9797     wxPy_END_ALLOW_THREADS;
9798     if (PyErr_Occurred()) return NULL;
9799 }    Py_INCREF(Py_None);
9800     _resultobj = Py_None;
9801     return _resultobj;
9802 }
9803
9804 #define wxGrid_SetCellHighlightColour(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightColour(_swigarg0))
9805 static PyObject *_wrap_wxGrid_SetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9806     PyObject * _resultobj;
9807     wxGrid * _arg0;
9808     wxColour * _arg1;
9809     PyObject * _argo0 = 0;
9810     wxColour  temp;
9811     PyObject * _obj1 = 0;
9812     char *_kwnames[] = { "self","arg2", NULL };
9813
9814     self = self;
9815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetCellHighlightColour",_kwnames,&_argo0,&_obj1))
9816         return NULL;
9817     if (_argo0) {
9818         if (_argo0 == Py_None) { _arg0 = NULL; }
9819         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9820             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightColour. Expected _wxGrid_p.");
9821         return NULL;
9822         }
9823     }
9824 {
9825     _arg1 = &temp;
9826     if (! wxColour_helper(_obj1, &_arg1))
9827         return NULL;
9828 }
9829 {
9830     wxPy_BEGIN_ALLOW_THREADS;
9831         wxGrid_SetCellHighlightColour(_arg0,*_arg1);
9832
9833     wxPy_END_ALLOW_THREADS;
9834     if (PyErr_Occurred()) return NULL;
9835 }    Py_INCREF(Py_None);
9836     _resultobj = Py_None;
9837     return _resultobj;
9838 }
9839
9840 #define wxGrid_SetCellHighlightPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightPenWidth(_swigarg0))
9841 static PyObject *_wrap_wxGrid_SetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9842     PyObject * _resultobj;
9843     wxGrid * _arg0;
9844     int  _arg1;
9845     PyObject * _argo0 = 0;
9846     char *_kwnames[] = { "self","width", NULL };
9847
9848     self = self;
9849     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightPenWidth",_kwnames,&_argo0,&_arg1))
9850         return NULL;
9851     if (_argo0) {
9852         if (_argo0 == Py_None) { _arg0 = NULL; }
9853         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9854             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightPenWidth. Expected _wxGrid_p.");
9855         return NULL;
9856         }
9857     }
9858 {
9859     wxPy_BEGIN_ALLOW_THREADS;
9860         wxGrid_SetCellHighlightPenWidth(_arg0,_arg1);
9861
9862     wxPy_END_ALLOW_THREADS;
9863     if (PyErr_Occurred()) return NULL;
9864 }    Py_INCREF(Py_None);
9865     _resultobj = Py_None;
9866     return _resultobj;
9867 }
9868
9869 #define wxGrid_SetCellHighlightROPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightROPenWidth(_swigarg0))
9870 static PyObject *_wrap_wxGrid_SetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9871     PyObject * _resultobj;
9872     wxGrid * _arg0;
9873     int  _arg1;
9874     PyObject * _argo0 = 0;
9875     char *_kwnames[] = { "self","width", NULL };
9876
9877     self = self;
9878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightROPenWidth",_kwnames,&_argo0,&_arg1))
9879         return NULL;
9880     if (_argo0) {
9881         if (_argo0 == Py_None) { _arg0 = NULL; }
9882         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9883             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightROPenWidth. Expected _wxGrid_p.");
9884         return NULL;
9885         }
9886     }
9887 {
9888     wxPy_BEGIN_ALLOW_THREADS;
9889         wxGrid_SetCellHighlightROPenWidth(_arg0,_arg1);
9890
9891     wxPy_END_ALLOW_THREADS;
9892     if (PyErr_Occurred()) return NULL;
9893 }    Py_INCREF(Py_None);
9894     _resultobj = Py_None;
9895     return _resultobj;
9896 }
9897
9898 #define wxGrid_EnableDragRowSize(_swigobj,_swigarg0)  (_swigobj->EnableDragRowSize(_swigarg0))
9899 static PyObject *_wrap_wxGrid_EnableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9900     PyObject * _resultobj;
9901     wxGrid * _arg0;
9902     bool  _arg1 = (bool ) TRUE;
9903     PyObject * _argo0 = 0;
9904     int tempbool1 = (int) TRUE;
9905     char *_kwnames[] = { "self","enable", NULL };
9906
9907     self = self;
9908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragRowSize",_kwnames,&_argo0,&tempbool1))
9909         return NULL;
9910     if (_argo0) {
9911         if (_argo0 == Py_None) { _arg0 = NULL; }
9912         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9913             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragRowSize. Expected _wxGrid_p.");
9914         return NULL;
9915         }
9916     }
9917     _arg1 = (bool ) tempbool1;
9918 {
9919     wxPy_BEGIN_ALLOW_THREADS;
9920         wxGrid_EnableDragRowSize(_arg0,_arg1);
9921
9922     wxPy_END_ALLOW_THREADS;
9923     if (PyErr_Occurred()) return NULL;
9924 }    Py_INCREF(Py_None);
9925     _resultobj = Py_None;
9926     return _resultobj;
9927 }
9928
9929 #define wxGrid_DisableDragRowSize(_swigobj)  (_swigobj->DisableDragRowSize())
9930 static PyObject *_wrap_wxGrid_DisableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9931     PyObject * _resultobj;
9932     wxGrid * _arg0;
9933     PyObject * _argo0 = 0;
9934     char *_kwnames[] = { "self", NULL };
9935
9936     self = self;
9937     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragRowSize",_kwnames,&_argo0))
9938         return NULL;
9939     if (_argo0) {
9940         if (_argo0 == Py_None) { _arg0 = NULL; }
9941         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9942             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragRowSize. Expected _wxGrid_p.");
9943         return NULL;
9944         }
9945     }
9946 {
9947     wxPy_BEGIN_ALLOW_THREADS;
9948         wxGrid_DisableDragRowSize(_arg0);
9949
9950     wxPy_END_ALLOW_THREADS;
9951     if (PyErr_Occurred()) return NULL;
9952 }    Py_INCREF(Py_None);
9953     _resultobj = Py_None;
9954     return _resultobj;
9955 }
9956
9957 #define wxGrid_CanDragRowSize(_swigobj)  (_swigobj->CanDragRowSize())
9958 static PyObject *_wrap_wxGrid_CanDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9959     PyObject * _resultobj;
9960     bool  _result;
9961     wxGrid * _arg0;
9962     PyObject * _argo0 = 0;
9963     char *_kwnames[] = { "self", NULL };
9964
9965     self = self;
9966     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragRowSize",_kwnames,&_argo0))
9967         return NULL;
9968     if (_argo0) {
9969         if (_argo0 == Py_None) { _arg0 = NULL; }
9970         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9971             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragRowSize. Expected _wxGrid_p.");
9972         return NULL;
9973         }
9974     }
9975 {
9976     wxPy_BEGIN_ALLOW_THREADS;
9977         _result = (bool )wxGrid_CanDragRowSize(_arg0);
9978
9979     wxPy_END_ALLOW_THREADS;
9980     if (PyErr_Occurred()) return NULL;
9981 }    _resultobj = Py_BuildValue("i",_result);
9982     return _resultobj;
9983 }
9984
9985 #define wxGrid_EnableDragColSize(_swigobj,_swigarg0)  (_swigobj->EnableDragColSize(_swigarg0))
9986 static PyObject *_wrap_wxGrid_EnableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9987     PyObject * _resultobj;
9988     wxGrid * _arg0;
9989     bool  _arg1 = (bool ) TRUE;
9990     PyObject * _argo0 = 0;
9991     int tempbool1 = (int) TRUE;
9992     char *_kwnames[] = { "self","enable", NULL };
9993
9994     self = self;
9995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragColSize",_kwnames,&_argo0,&tempbool1))
9996         return NULL;
9997     if (_argo0) {
9998         if (_argo0 == Py_None) { _arg0 = NULL; }
9999         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10000             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragColSize. Expected _wxGrid_p.");
10001         return NULL;
10002         }
10003     }
10004     _arg1 = (bool ) tempbool1;
10005 {
10006     wxPy_BEGIN_ALLOW_THREADS;
10007         wxGrid_EnableDragColSize(_arg0,_arg1);
10008
10009     wxPy_END_ALLOW_THREADS;
10010     if (PyErr_Occurred()) return NULL;
10011 }    Py_INCREF(Py_None);
10012     _resultobj = Py_None;
10013     return _resultobj;
10014 }
10015
10016 #define wxGrid_DisableDragColSize(_swigobj)  (_swigobj->DisableDragColSize())
10017 static PyObject *_wrap_wxGrid_DisableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10018     PyObject * _resultobj;
10019     wxGrid * _arg0;
10020     PyObject * _argo0 = 0;
10021     char *_kwnames[] = { "self", NULL };
10022
10023     self = self;
10024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragColSize",_kwnames,&_argo0))
10025         return NULL;
10026     if (_argo0) {
10027         if (_argo0 == Py_None) { _arg0 = NULL; }
10028         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10029             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragColSize. Expected _wxGrid_p.");
10030         return NULL;
10031         }
10032     }
10033 {
10034     wxPy_BEGIN_ALLOW_THREADS;
10035         wxGrid_DisableDragColSize(_arg0);
10036
10037     wxPy_END_ALLOW_THREADS;
10038     if (PyErr_Occurred()) return NULL;
10039 }    Py_INCREF(Py_None);
10040     _resultobj = Py_None;
10041     return _resultobj;
10042 }
10043
10044 #define wxGrid_CanDragColSize(_swigobj)  (_swigobj->CanDragColSize())
10045 static PyObject *_wrap_wxGrid_CanDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10046     PyObject * _resultobj;
10047     bool  _result;
10048     wxGrid * _arg0;
10049     PyObject * _argo0 = 0;
10050     char *_kwnames[] = { "self", NULL };
10051
10052     self = self;
10053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragColSize",_kwnames,&_argo0))
10054         return NULL;
10055     if (_argo0) {
10056         if (_argo0 == Py_None) { _arg0 = NULL; }
10057         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10058             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragColSize. Expected _wxGrid_p.");
10059         return NULL;
10060         }
10061     }
10062 {
10063     wxPy_BEGIN_ALLOW_THREADS;
10064         _result = (bool )wxGrid_CanDragColSize(_arg0);
10065
10066     wxPy_END_ALLOW_THREADS;
10067     if (PyErr_Occurred()) return NULL;
10068 }    _resultobj = Py_BuildValue("i",_result);
10069     return _resultobj;
10070 }
10071
10072 #define wxGrid_EnableDragGridSize(_swigobj,_swigarg0)  (_swigobj->EnableDragGridSize(_swigarg0))
10073 static PyObject *_wrap_wxGrid_EnableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10074     PyObject * _resultobj;
10075     wxGrid * _arg0;
10076     bool  _arg1 = (bool ) TRUE;
10077     PyObject * _argo0 = 0;
10078     int tempbool1 = (int) TRUE;
10079     char *_kwnames[] = { "self","enable", NULL };
10080
10081     self = self;
10082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragGridSize",_kwnames,&_argo0,&tempbool1))
10083         return NULL;
10084     if (_argo0) {
10085         if (_argo0 == Py_None) { _arg0 = NULL; }
10086         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10087             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragGridSize. Expected _wxGrid_p.");
10088         return NULL;
10089         }
10090     }
10091     _arg1 = (bool ) tempbool1;
10092 {
10093     wxPy_BEGIN_ALLOW_THREADS;
10094         wxGrid_EnableDragGridSize(_arg0,_arg1);
10095
10096     wxPy_END_ALLOW_THREADS;
10097     if (PyErr_Occurred()) return NULL;
10098 }    Py_INCREF(Py_None);
10099     _resultobj = Py_None;
10100     return _resultobj;
10101 }
10102
10103 #define wxGrid_DisableDragGridSize(_swigobj)  (_swigobj->DisableDragGridSize())
10104 static PyObject *_wrap_wxGrid_DisableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10105     PyObject * _resultobj;
10106     wxGrid * _arg0;
10107     PyObject * _argo0 = 0;
10108     char *_kwnames[] = { "self", NULL };
10109
10110     self = self;
10111     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragGridSize",_kwnames,&_argo0))
10112         return NULL;
10113     if (_argo0) {
10114         if (_argo0 == Py_None) { _arg0 = NULL; }
10115         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10116             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragGridSize. Expected _wxGrid_p.");
10117         return NULL;
10118         }
10119     }
10120 {
10121     wxPy_BEGIN_ALLOW_THREADS;
10122         wxGrid_DisableDragGridSize(_arg0);
10123
10124     wxPy_END_ALLOW_THREADS;
10125     if (PyErr_Occurred()) return NULL;
10126 }    Py_INCREF(Py_None);
10127     _resultobj = Py_None;
10128     return _resultobj;
10129 }
10130
10131 #define wxGrid_CanDragGridSize(_swigobj)  (_swigobj->CanDragGridSize())
10132 static PyObject *_wrap_wxGrid_CanDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10133     PyObject * _resultobj;
10134     bool  _result;
10135     wxGrid * _arg0;
10136     PyObject * _argo0 = 0;
10137     char *_kwnames[] = { "self", NULL };
10138
10139     self = self;
10140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragGridSize",_kwnames,&_argo0))
10141         return NULL;
10142     if (_argo0) {
10143         if (_argo0 == Py_None) { _arg0 = NULL; }
10144         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10145             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragGridSize. Expected _wxGrid_p.");
10146         return NULL;
10147         }
10148     }
10149 {
10150     wxPy_BEGIN_ALLOW_THREADS;
10151         _result = (bool )wxGrid_CanDragGridSize(_arg0);
10152
10153     wxPy_END_ALLOW_THREADS;
10154     if (PyErr_Occurred()) return NULL;
10155 }    _resultobj = Py_BuildValue("i",_result);
10156     return _resultobj;
10157 }
10158
10159 #define wxGrid_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
10160 static PyObject *_wrap_wxGrid_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10161     PyObject * _resultobj;
10162     wxGrid * _arg0;
10163     int  _arg1;
10164     wxGridCellAttr * _arg2;
10165     PyObject * _argo0 = 0;
10166     PyObject * _argo2 = 0;
10167     char *_kwnames[] = { "self","row","attr", NULL };
10168
10169     self = self;
10170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10171         return NULL;
10172     if (_argo0) {
10173         if (_argo0 == Py_None) { _arg0 = NULL; }
10174         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10175             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowAttr. Expected _wxGrid_p.");
10176         return NULL;
10177         }
10178     }
10179     if (_argo2) {
10180         if (_argo2 == Py_None) { _arg2 = NULL; }
10181         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10182             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetRowAttr. Expected _wxGridCellAttr_p.");
10183         return NULL;
10184         }
10185     }
10186 {
10187     wxPy_BEGIN_ALLOW_THREADS;
10188         wxGrid_SetRowAttr(_arg0,_arg1,_arg2);
10189
10190     wxPy_END_ALLOW_THREADS;
10191     if (PyErr_Occurred()) return NULL;
10192 }    Py_INCREF(Py_None);
10193     _resultobj = Py_None;
10194     return _resultobj;
10195 }
10196
10197 #define wxGrid_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
10198 static PyObject *_wrap_wxGrid_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10199     PyObject * _resultobj;
10200     wxGrid * _arg0;
10201     int  _arg1;
10202     wxGridCellAttr * _arg2;
10203     PyObject * _argo0 = 0;
10204     PyObject * _argo2 = 0;
10205     char *_kwnames[] = { "self","col","attr", NULL };
10206
10207     self = self;
10208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10209         return NULL;
10210     if (_argo0) {
10211         if (_argo0 == Py_None) { _arg0 = NULL; }
10212         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10213             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColAttr. Expected _wxGrid_p.");
10214         return NULL;
10215         }
10216     }
10217     if (_argo2) {
10218         if (_argo2 == Py_None) { _arg2 = NULL; }
10219         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10220             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetColAttr. Expected _wxGridCellAttr_p.");
10221         return NULL;
10222         }
10223     }
10224 {
10225     wxPy_BEGIN_ALLOW_THREADS;
10226         wxGrid_SetColAttr(_arg0,_arg1,_arg2);
10227
10228     wxPy_END_ALLOW_THREADS;
10229     if (PyErr_Occurred()) return NULL;
10230 }    Py_INCREF(Py_None);
10231     _resultobj = Py_None;
10232     return _resultobj;
10233 }
10234
10235 #define wxGrid_SetColFormatBool(_swigobj,_swigarg0)  (_swigobj->SetColFormatBool(_swigarg0))
10236 static PyObject *_wrap_wxGrid_SetColFormatBool(PyObject *self, PyObject *args, PyObject *kwargs) {
10237     PyObject * _resultobj;
10238     wxGrid * _arg0;
10239     int  _arg1;
10240     PyObject * _argo0 = 0;
10241     char *_kwnames[] = { "self","col", NULL };
10242
10243     self = self;
10244     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatBool",_kwnames,&_argo0,&_arg1))
10245         return NULL;
10246     if (_argo0) {
10247         if (_argo0 == Py_None) { _arg0 = NULL; }
10248         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10249             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatBool. Expected _wxGrid_p.");
10250         return NULL;
10251         }
10252     }
10253 {
10254     wxPy_BEGIN_ALLOW_THREADS;
10255         wxGrid_SetColFormatBool(_arg0,_arg1);
10256
10257     wxPy_END_ALLOW_THREADS;
10258     if (PyErr_Occurred()) return NULL;
10259 }    Py_INCREF(Py_None);
10260     _resultobj = Py_None;
10261     return _resultobj;
10262 }
10263
10264 #define wxGrid_SetColFormatNumber(_swigobj,_swigarg0)  (_swigobj->SetColFormatNumber(_swigarg0))
10265 static PyObject *_wrap_wxGrid_SetColFormatNumber(PyObject *self, PyObject *args, PyObject *kwargs) {
10266     PyObject * _resultobj;
10267     wxGrid * _arg0;
10268     int  _arg1;
10269     PyObject * _argo0 = 0;
10270     char *_kwnames[] = { "self","col", NULL };
10271
10272     self = self;
10273     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatNumber",_kwnames,&_argo0,&_arg1))
10274         return NULL;
10275     if (_argo0) {
10276         if (_argo0 == Py_None) { _arg0 = NULL; }
10277         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10278             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatNumber. Expected _wxGrid_p.");
10279         return NULL;
10280         }
10281     }
10282 {
10283     wxPy_BEGIN_ALLOW_THREADS;
10284         wxGrid_SetColFormatNumber(_arg0,_arg1);
10285
10286     wxPy_END_ALLOW_THREADS;
10287     if (PyErr_Occurred()) return NULL;
10288 }    Py_INCREF(Py_None);
10289     _resultobj = Py_None;
10290     return _resultobj;
10291 }
10292
10293 #define wxGrid_SetColFormatFloat(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetColFormatFloat(_swigarg0,_swigarg1,_swigarg2))
10294 static PyObject *_wrap_wxGrid_SetColFormatFloat(PyObject *self, PyObject *args, PyObject *kwargs) {
10295     PyObject * _resultobj;
10296     wxGrid * _arg0;
10297     int  _arg1;
10298     int  _arg2 = (int ) -1;
10299     int  _arg3 = (int ) -1;
10300     PyObject * _argo0 = 0;
10301     char *_kwnames[] = { "self","col","width","precision", NULL };
10302
10303     self = self;
10304     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|ii:wxGrid_SetColFormatFloat",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
10305         return NULL;
10306     if (_argo0) {
10307         if (_argo0 == Py_None) { _arg0 = NULL; }
10308         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10309             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatFloat. Expected _wxGrid_p.");
10310         return NULL;
10311         }
10312     }
10313 {
10314     wxPy_BEGIN_ALLOW_THREADS;
10315         wxGrid_SetColFormatFloat(_arg0,_arg1,_arg2,_arg3);
10316
10317     wxPy_END_ALLOW_THREADS;
10318     if (PyErr_Occurred()) return NULL;
10319 }    Py_INCREF(Py_None);
10320     _resultobj = Py_None;
10321     return _resultobj;
10322 }
10323
10324 #define wxGrid_SetColFormatCustom(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColFormatCustom(_swigarg0,_swigarg1))
10325 static PyObject *_wrap_wxGrid_SetColFormatCustom(PyObject *self, PyObject *args, PyObject *kwargs) {
10326     PyObject * _resultobj;
10327     wxGrid * _arg0;
10328     int  _arg1;
10329     wxString * _arg2;
10330     PyObject * _argo0 = 0;
10331     PyObject * _obj2 = 0;
10332     char *_kwnames[] = { "self","col","typeName", NULL };
10333
10334     self = self;
10335     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColFormatCustom",_kwnames,&_argo0,&_arg1,&_obj2))
10336         return NULL;
10337     if (_argo0) {
10338         if (_argo0 == Py_None) { _arg0 = NULL; }
10339         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10340             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatCustom. Expected _wxGrid_p.");
10341         return NULL;
10342         }
10343     }
10344 {
10345 #if PYTHON_API_VERSION >= 1009
10346     char* tmpPtr; int tmpSize;
10347     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
10348         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10349         return NULL;
10350     }
10351     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
10352         return NULL;
10353     _arg2 = new wxString(tmpPtr, tmpSize);
10354 #else
10355     if (!PyString_Check(_obj2)) {
10356         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10357         return NULL;
10358     }
10359     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
10360 #endif
10361 }
10362 {
10363     wxPy_BEGIN_ALLOW_THREADS;
10364         wxGrid_SetColFormatCustom(_arg0,_arg1,*_arg2);
10365
10366     wxPy_END_ALLOW_THREADS;
10367     if (PyErr_Occurred()) return NULL;
10368 }    Py_INCREF(Py_None);
10369     _resultobj = Py_None;
10370 {
10371     if (_obj2)
10372         delete _arg2;
10373 }
10374     return _resultobj;
10375 }
10376
10377 #define wxGrid_EnableGridLines(_swigobj,_swigarg0)  (_swigobj->EnableGridLines(_swigarg0))
10378 static PyObject *_wrap_wxGrid_EnableGridLines(PyObject *self, PyObject *args, PyObject *kwargs) {
10379     PyObject * _resultobj;
10380     wxGrid * _arg0;
10381     bool  _arg1 = (bool ) TRUE;
10382     PyObject * _argo0 = 0;
10383     int tempbool1 = (int) TRUE;
10384     char *_kwnames[] = { "self","enable", NULL };
10385
10386     self = self;
10387     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableGridLines",_kwnames,&_argo0,&tempbool1))
10388         return NULL;
10389     if (_argo0) {
10390         if (_argo0 == Py_None) { _arg0 = NULL; }
10391         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10392             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableGridLines. Expected _wxGrid_p.");
10393         return NULL;
10394         }
10395     }
10396     _arg1 = (bool ) tempbool1;
10397 {
10398     wxPy_BEGIN_ALLOW_THREADS;
10399         wxGrid_EnableGridLines(_arg0,_arg1);
10400
10401     wxPy_END_ALLOW_THREADS;
10402     if (PyErr_Occurred()) return NULL;
10403 }    Py_INCREF(Py_None);
10404     _resultobj = Py_None;
10405     return _resultobj;
10406 }
10407
10408 #define wxGrid_GridLinesEnabled(_swigobj)  (_swigobj->GridLinesEnabled())
10409 static PyObject *_wrap_wxGrid_GridLinesEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
10410     PyObject * _resultobj;
10411     bool  _result;
10412     wxGrid * _arg0;
10413     PyObject * _argo0 = 0;
10414     char *_kwnames[] = { "self", NULL };
10415
10416     self = self;
10417     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GridLinesEnabled",_kwnames,&_argo0))
10418         return NULL;
10419     if (_argo0) {
10420         if (_argo0 == Py_None) { _arg0 = NULL; }
10421         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10422             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GridLinesEnabled. Expected _wxGrid_p.");
10423         return NULL;
10424         }
10425     }
10426 {
10427     wxPy_BEGIN_ALLOW_THREADS;
10428         _result = (bool )wxGrid_GridLinesEnabled(_arg0);
10429
10430     wxPy_END_ALLOW_THREADS;
10431     if (PyErr_Occurred()) return NULL;
10432 }    _resultobj = Py_BuildValue("i",_result);
10433     return _resultobj;
10434 }
10435
10436 #define wxGrid_GetDefaultRowSize(_swigobj)  (_swigobj->GetDefaultRowSize())
10437 static PyObject *_wrap_wxGrid_GetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10438     PyObject * _resultobj;
10439     int  _result;
10440     wxGrid * _arg0;
10441     PyObject * _argo0 = 0;
10442     char *_kwnames[] = { "self", NULL };
10443
10444     self = self;
10445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowSize",_kwnames,&_argo0))
10446         return NULL;
10447     if (_argo0) {
10448         if (_argo0 == Py_None) { _arg0 = NULL; }
10449         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10450             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowSize. Expected _wxGrid_p.");
10451         return NULL;
10452         }
10453     }
10454 {
10455     wxPy_BEGIN_ALLOW_THREADS;
10456         _result = (int )wxGrid_GetDefaultRowSize(_arg0);
10457
10458     wxPy_END_ALLOW_THREADS;
10459     if (PyErr_Occurred()) return NULL;
10460 }    _resultobj = Py_BuildValue("i",_result);
10461     return _resultobj;
10462 }
10463
10464 #define wxGrid_GetRowSize(_swigobj,_swigarg0)  (_swigobj->GetRowSize(_swigarg0))
10465 static PyObject *_wrap_wxGrid_GetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10466     PyObject * _resultobj;
10467     int  _result;
10468     wxGrid * _arg0;
10469     int  _arg1;
10470     PyObject * _argo0 = 0;
10471     char *_kwnames[] = { "self","row", NULL };
10472
10473     self = self;
10474     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowSize",_kwnames,&_argo0,&_arg1))
10475         return NULL;
10476     if (_argo0) {
10477         if (_argo0 == Py_None) { _arg0 = NULL; }
10478         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10479             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowSize. Expected _wxGrid_p.");
10480         return NULL;
10481         }
10482     }
10483 {
10484     wxPy_BEGIN_ALLOW_THREADS;
10485         _result = (int )wxGrid_GetRowSize(_arg0,_arg1);
10486
10487     wxPy_END_ALLOW_THREADS;
10488     if (PyErr_Occurred()) return NULL;
10489 }    _resultobj = Py_BuildValue("i",_result);
10490     return _resultobj;
10491 }
10492
10493 #define wxGrid_GetDefaultColSize(_swigobj)  (_swigobj->GetDefaultColSize())
10494 static PyObject *_wrap_wxGrid_GetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10495     PyObject * _resultobj;
10496     int  _result;
10497     wxGrid * _arg0;
10498     PyObject * _argo0 = 0;
10499     char *_kwnames[] = { "self", NULL };
10500
10501     self = self;
10502     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColSize",_kwnames,&_argo0))
10503         return NULL;
10504     if (_argo0) {
10505         if (_argo0 == Py_None) { _arg0 = NULL; }
10506         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10507             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColSize. Expected _wxGrid_p.");
10508         return NULL;
10509         }
10510     }
10511 {
10512     wxPy_BEGIN_ALLOW_THREADS;
10513         _result = (int )wxGrid_GetDefaultColSize(_arg0);
10514
10515     wxPy_END_ALLOW_THREADS;
10516     if (PyErr_Occurred()) return NULL;
10517 }    _resultobj = Py_BuildValue("i",_result);
10518     return _resultobj;
10519 }
10520
10521 #define wxGrid_GetColSize(_swigobj,_swigarg0)  (_swigobj->GetColSize(_swigarg0))
10522 static PyObject *_wrap_wxGrid_GetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10523     PyObject * _resultobj;
10524     int  _result;
10525     wxGrid * _arg0;
10526     int  _arg1;
10527     PyObject * _argo0 = 0;
10528     char *_kwnames[] = { "self","col", NULL };
10529
10530     self = self;
10531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColSize",_kwnames,&_argo0,&_arg1))
10532         return NULL;
10533     if (_argo0) {
10534         if (_argo0 == Py_None) { _arg0 = NULL; }
10535         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10536             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColSize. Expected _wxGrid_p.");
10537         return NULL;
10538         }
10539     }
10540 {
10541     wxPy_BEGIN_ALLOW_THREADS;
10542         _result = (int )wxGrid_GetColSize(_arg0,_arg1);
10543
10544     wxPy_END_ALLOW_THREADS;
10545     if (PyErr_Occurred()) return NULL;
10546 }    _resultobj = Py_BuildValue("i",_result);
10547     return _resultobj;
10548 }
10549
10550 #define wxGrid_GetDefaultCellBackgroundColour(_swigobj)  (_swigobj->GetDefaultCellBackgroundColour())
10551 static PyObject *_wrap_wxGrid_GetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10552     PyObject * _resultobj;
10553     wxColour * _result;
10554     wxGrid * _arg0;
10555     PyObject * _argo0 = 0;
10556     char *_kwnames[] = { "self", NULL };
10557     char _ptemp[128];
10558
10559     self = self;
10560     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellBackgroundColour",_kwnames,&_argo0))
10561         return NULL;
10562     if (_argo0) {
10563         if (_argo0 == Py_None) { _arg0 = NULL; }
10564         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10565             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellBackgroundColour. Expected _wxGrid_p.");
10566         return NULL;
10567         }
10568     }
10569 {
10570     wxPy_BEGIN_ALLOW_THREADS;
10571         _result = new wxColour (wxGrid_GetDefaultCellBackgroundColour(_arg0));
10572
10573     wxPy_END_ALLOW_THREADS;
10574     if (PyErr_Occurred()) return NULL;
10575 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10576     _resultobj = Py_BuildValue("s",_ptemp);
10577     return _resultobj;
10578 }
10579
10580 #define wxGrid_GetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellBackgroundColour(_swigarg0,_swigarg1))
10581 static PyObject *_wrap_wxGrid_GetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10582     PyObject * _resultobj;
10583     wxColour * _result;
10584     wxGrid * _arg0;
10585     int  _arg1;
10586     int  _arg2;
10587     PyObject * _argo0 = 0;
10588     char *_kwnames[] = { "self","row","col", NULL };
10589     char _ptemp[128];
10590
10591     self = self;
10592     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2))
10593         return NULL;
10594     if (_argo0) {
10595         if (_argo0 == Py_None) { _arg0 = NULL; }
10596         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10597             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellBackgroundColour. Expected _wxGrid_p.");
10598         return NULL;
10599         }
10600     }
10601 {
10602     wxPy_BEGIN_ALLOW_THREADS;
10603         _result = new wxColour (wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2));
10604
10605     wxPy_END_ALLOW_THREADS;
10606     if (PyErr_Occurred()) return NULL;
10607 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10608     _resultobj = Py_BuildValue("s",_ptemp);
10609     return _resultobj;
10610 }
10611
10612 #define wxGrid_GetDefaultCellTextColour(_swigobj)  (_swigobj->GetDefaultCellTextColour())
10613 static PyObject *_wrap_wxGrid_GetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10614     PyObject * _resultobj;
10615     wxColour * _result;
10616     wxGrid * _arg0;
10617     PyObject * _argo0 = 0;
10618     char *_kwnames[] = { "self", NULL };
10619     char _ptemp[128];
10620
10621     self = self;
10622     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellTextColour",_kwnames,&_argo0))
10623         return NULL;
10624     if (_argo0) {
10625         if (_argo0 == Py_None) { _arg0 = NULL; }
10626         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10627             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellTextColour. Expected _wxGrid_p.");
10628         return NULL;
10629         }
10630     }
10631 {
10632     wxPy_BEGIN_ALLOW_THREADS;
10633         _result = new wxColour (wxGrid_GetDefaultCellTextColour(_arg0));
10634
10635     wxPy_END_ALLOW_THREADS;
10636     if (PyErr_Occurred()) return NULL;
10637 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10638     _resultobj = Py_BuildValue("s",_ptemp);
10639     return _resultobj;
10640 }
10641
10642 #define wxGrid_GetCellTextColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellTextColour(_swigarg0,_swigarg1))
10643 static PyObject *_wrap_wxGrid_GetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10644     PyObject * _resultobj;
10645     wxColour * _result;
10646     wxGrid * _arg0;
10647     int  _arg1;
10648     int  _arg2;
10649     PyObject * _argo0 = 0;
10650     char *_kwnames[] = { "self","row","col", NULL };
10651     char _ptemp[128];
10652
10653     self = self;
10654     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2))
10655         return NULL;
10656     if (_argo0) {
10657         if (_argo0 == Py_None) { _arg0 = NULL; }
10658         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10659             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellTextColour. Expected _wxGrid_p.");
10660         return NULL;
10661         }
10662     }
10663 {
10664     wxPy_BEGIN_ALLOW_THREADS;
10665         _result = new wxColour (wxGrid_GetCellTextColour(_arg0,_arg1,_arg2));
10666
10667     wxPy_END_ALLOW_THREADS;
10668     if (PyErr_Occurred()) return NULL;
10669 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10670     _resultobj = Py_BuildValue("s",_ptemp);
10671     return _resultobj;
10672 }
10673
10674 #define wxGrid_GetDefaultCellFont(_swigobj)  (_swigobj->GetDefaultCellFont())
10675 static PyObject *_wrap_wxGrid_GetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10676     PyObject * _resultobj;
10677     wxFont * _result;
10678     wxGrid * _arg0;
10679     PyObject * _argo0 = 0;
10680     char *_kwnames[] = { "self", NULL };
10681     char _ptemp[128];
10682
10683     self = self;
10684     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellFont",_kwnames,&_argo0))
10685         return NULL;
10686     if (_argo0) {
10687         if (_argo0 == Py_None) { _arg0 = NULL; }
10688         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10689             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellFont. Expected _wxGrid_p.");
10690         return NULL;
10691         }
10692     }
10693 {
10694     wxPy_BEGIN_ALLOW_THREADS;
10695         _result = new wxFont (wxGrid_GetDefaultCellFont(_arg0));
10696
10697     wxPy_END_ALLOW_THREADS;
10698     if (PyErr_Occurred()) return NULL;
10699 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10700     _resultobj = Py_BuildValue("s",_ptemp);
10701     return _resultobj;
10702 }
10703
10704 #define wxGrid_GetCellFont(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellFont(_swigarg0,_swigarg1))
10705 static PyObject *_wrap_wxGrid_GetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10706     PyObject * _resultobj;
10707     wxFont * _result;
10708     wxGrid * _arg0;
10709     int  _arg1;
10710     int  _arg2;
10711     PyObject * _argo0 = 0;
10712     char *_kwnames[] = { "self","row","col", NULL };
10713     char _ptemp[128];
10714
10715     self = self;
10716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellFont",_kwnames,&_argo0,&_arg1,&_arg2))
10717         return NULL;
10718     if (_argo0) {
10719         if (_argo0 == Py_None) { _arg0 = NULL; }
10720         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10721             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellFont. Expected _wxGrid_p.");
10722         return NULL;
10723         }
10724     }
10725 {
10726     wxPy_BEGIN_ALLOW_THREADS;
10727         _result = new wxFont (wxGrid_GetCellFont(_arg0,_arg1,_arg2));
10728
10729     wxPy_END_ALLOW_THREADS;
10730     if (PyErr_Occurred()) return NULL;
10731 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10732     _resultobj = Py_BuildValue("s",_ptemp);
10733     return _resultobj;
10734 }
10735
10736 #define wxGrid_GetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultCellAlignment(_swigarg0,_swigarg1))
10737 static PyObject *_wrap_wxGrid_GetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10738     PyObject * _resultobj;
10739     wxGrid * _arg0;
10740     int * _arg1;
10741     int * _arg2;
10742     PyObject * _argo0 = 0;
10743     PyObject * _argo1 = 0;
10744     PyObject * _argo2 = 0;
10745     char *_kwnames[] = { "self","horiz","vert", NULL };
10746
10747     self = self;
10748     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetDefaultCellAlignment",_kwnames,&_argo0,&_argo1,&_argo2))
10749         return NULL;
10750     if (_argo0) {
10751         if (_argo0 == Py_None) { _arg0 = NULL; }
10752         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10753             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellAlignment. Expected _wxGrid_p.");
10754         return NULL;
10755         }
10756     }
10757     if (_argo1) {
10758         if (_argo1 == Py_None) { _arg1 = NULL; }
10759         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_int_p")) {
10760             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10761         return NULL;
10762         }
10763     }
10764     if (_argo2) {
10765         if (_argo2 == Py_None) { _arg2 = NULL; }
10766         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_int_p")) {
10767             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10768         return NULL;
10769         }
10770     }
10771 {
10772     wxPy_BEGIN_ALLOW_THREADS;
10773         wxGrid_GetDefaultCellAlignment(_arg0,_arg1,_arg2);
10774
10775     wxPy_END_ALLOW_THREADS;
10776     if (PyErr_Occurred()) return NULL;
10777 }    Py_INCREF(Py_None);
10778     _resultobj = Py_None;
10779     return _resultobj;
10780 }
10781
10782 #define wxGrid_GetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
10783 static PyObject *_wrap_wxGrid_GetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10784     PyObject * _resultobj;
10785     wxGrid * _arg0;
10786     int  _arg1;
10787     int  _arg2;
10788     int * _arg3;
10789     int * _arg4;
10790     PyObject * _argo0 = 0;
10791     PyObject * _argo3 = 0;
10792     PyObject * _argo4 = 0;
10793     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
10794
10795     self = self;
10796     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiOO:wxGrid_GetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4))
10797         return NULL;
10798     if (_argo0) {
10799         if (_argo0 == Py_None) { _arg0 = NULL; }
10800         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10801             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellAlignment. Expected _wxGrid_p.");
10802         return NULL;
10803         }
10804     }
10805     if (_argo3) {
10806         if (_argo3 == Py_None) { _arg3 = NULL; }
10807         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_int_p")) {
10808             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_GetCellAlignment. Expected _int_p.");
10809         return NULL;
10810         }
10811     }
10812     if (_argo4) {
10813         if (_argo4 == Py_None) { _arg4 = NULL; }
10814         else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_int_p")) {
10815             PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxGrid_GetCellAlignment. Expected _int_p.");
10816         return NULL;
10817         }
10818     }
10819 {
10820     wxPy_BEGIN_ALLOW_THREADS;
10821         wxGrid_GetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
10822
10823     wxPy_END_ALLOW_THREADS;
10824     if (PyErr_Occurred()) return NULL;
10825 }    Py_INCREF(Py_None);
10826     _resultobj = Py_None;
10827     return _resultobj;
10828 }
10829
10830 #define wxGrid_SetDefaultRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultRowSize(_swigarg0,_swigarg1))
10831 static PyObject *_wrap_wxGrid_SetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10832     PyObject * _resultobj;
10833     wxGrid * _arg0;
10834     int  _arg1;
10835     bool  _arg2 = (bool ) FALSE;
10836     PyObject * _argo0 = 0;
10837     int tempbool2 = (int) FALSE;
10838     char *_kwnames[] = { "self","height","resizeExistingRows", NULL };
10839
10840     self = self;
10841     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultRowSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10842         return NULL;
10843     if (_argo0) {
10844         if (_argo0 == Py_None) { _arg0 = NULL; }
10845         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10846             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRowSize. Expected _wxGrid_p.");
10847         return NULL;
10848         }
10849     }
10850     _arg2 = (bool ) tempbool2;
10851 {
10852     wxPy_BEGIN_ALLOW_THREADS;
10853         wxGrid_SetDefaultRowSize(_arg0,_arg1,_arg2);
10854
10855     wxPy_END_ALLOW_THREADS;
10856     if (PyErr_Occurred()) return NULL;
10857 }    Py_INCREF(Py_None);
10858     _resultobj = Py_None;
10859     return _resultobj;
10860 }
10861
10862 #define wxGrid_SetRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowSize(_swigarg0,_swigarg1))
10863 static PyObject *_wrap_wxGrid_SetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10864     PyObject * _resultobj;
10865     wxGrid * _arg0;
10866     int  _arg1;
10867     int  _arg2;
10868     PyObject * _argo0 = 0;
10869     char *_kwnames[] = { "self","row","height", NULL };
10870
10871     self = self;
10872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowSize",_kwnames,&_argo0,&_arg1,&_arg2))
10873         return NULL;
10874     if (_argo0) {
10875         if (_argo0 == Py_None) { _arg0 = NULL; }
10876         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10877             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowSize. Expected _wxGrid_p.");
10878         return NULL;
10879         }
10880     }
10881 {
10882     wxPy_BEGIN_ALLOW_THREADS;
10883         wxGrid_SetRowSize(_arg0,_arg1,_arg2);
10884
10885     wxPy_END_ALLOW_THREADS;
10886     if (PyErr_Occurred()) return NULL;
10887 }    Py_INCREF(Py_None);
10888     _resultobj = Py_None;
10889     return _resultobj;
10890 }
10891
10892 #define wxGrid_SetDefaultColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultColSize(_swigarg0,_swigarg1))
10893 static PyObject *_wrap_wxGrid_SetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10894     PyObject * _resultobj;
10895     wxGrid * _arg0;
10896     int  _arg1;
10897     bool  _arg2 = (bool ) FALSE;
10898     PyObject * _argo0 = 0;
10899     int tempbool2 = (int) FALSE;
10900     char *_kwnames[] = { "self","width","resizeExistingCols", NULL };
10901
10902     self = self;
10903     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultColSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10904         return NULL;
10905     if (_argo0) {
10906         if (_argo0 == Py_None) { _arg0 = NULL; }
10907         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10908             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultColSize. Expected _wxGrid_p.");
10909         return NULL;
10910         }
10911     }
10912     _arg2 = (bool ) tempbool2;
10913 {
10914     wxPy_BEGIN_ALLOW_THREADS;
10915         wxGrid_SetDefaultColSize(_arg0,_arg1,_arg2);
10916
10917     wxPy_END_ALLOW_THREADS;
10918     if (PyErr_Occurred()) return NULL;
10919 }    Py_INCREF(Py_None);
10920     _resultobj = Py_None;
10921     return _resultobj;
10922 }
10923
10924 #define wxGrid_SetColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColSize(_swigarg0,_swigarg1))
10925 static PyObject *_wrap_wxGrid_SetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10926     PyObject * _resultobj;
10927     wxGrid * _arg0;
10928     int  _arg1;
10929     int  _arg2;
10930     PyObject * _argo0 = 0;
10931     char *_kwnames[] = { "self","col","width", NULL };
10932
10933     self = self;
10934     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColSize",_kwnames,&_argo0,&_arg1,&_arg2))
10935         return NULL;
10936     if (_argo0) {
10937         if (_argo0 == Py_None) { _arg0 = NULL; }
10938         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10939             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColSize. Expected _wxGrid_p.");
10940         return NULL;
10941         }
10942     }
10943 {
10944     wxPy_BEGIN_ALLOW_THREADS;
10945         wxGrid_SetColSize(_arg0,_arg1,_arg2);
10946
10947     wxPy_END_ALLOW_THREADS;
10948     if (PyErr_Occurred()) return NULL;
10949 }    Py_INCREF(Py_None);
10950     _resultobj = Py_None;
10951     return _resultobj;
10952 }
10953
10954 #define wxGrid_AutoSizeColumn(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeColumn(_swigarg0,_swigarg1))
10955 static PyObject *_wrap_wxGrid_AutoSizeColumn(PyObject *self, PyObject *args, PyObject *kwargs) {
10956     PyObject * _resultobj;
10957     wxGrid * _arg0;
10958     int  _arg1;
10959     bool  _arg2 = (bool ) TRUE;
10960     PyObject * _argo0 = 0;
10961     int tempbool2 = (int) TRUE;
10962     char *_kwnames[] = { "self","col","setAsMin", NULL };
10963
10964     self = self;
10965     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeColumn",_kwnames,&_argo0,&_arg1,&tempbool2))
10966         return NULL;
10967     if (_argo0) {
10968         if (_argo0 == Py_None) { _arg0 = NULL; }
10969         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10970             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumn. Expected _wxGrid_p.");
10971         return NULL;
10972         }
10973     }
10974     _arg2 = (bool ) tempbool2;
10975 {
10976     wxPy_BEGIN_ALLOW_THREADS;
10977         wxGrid_AutoSizeColumn(_arg0,_arg1,_arg2);
10978
10979     wxPy_END_ALLOW_THREADS;
10980     if (PyErr_Occurred()) return NULL;
10981 }    Py_INCREF(Py_None);
10982     _resultobj = Py_None;
10983     return _resultobj;
10984 }
10985
10986 #define wxGrid_AutoSizeRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeRow(_swigarg0,_swigarg1))
10987 static PyObject *_wrap_wxGrid_AutoSizeRow(PyObject *self, PyObject *args, PyObject *kwargs) {
10988     PyObject * _resultobj;
10989     wxGrid * _arg0;
10990     int  _arg1;
10991     bool  _arg2 = (bool ) TRUE;
10992     PyObject * _argo0 = 0;
10993     int tempbool2 = (int) TRUE;
10994     char *_kwnames[] = { "self","row","setAsMin", NULL };
10995
10996     self = self;
10997     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeRow",_kwnames,&_argo0,&_arg1,&tempbool2))
10998         return NULL;
10999     if (_argo0) {
11000         if (_argo0 == Py_None) { _arg0 = NULL; }
11001         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11002             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRow. Expected _wxGrid_p.");
11003         return NULL;
11004         }
11005     }
11006     _arg2 = (bool ) tempbool2;
11007 {
11008     wxPy_BEGIN_ALLOW_THREADS;
11009         wxGrid_AutoSizeRow(_arg0,_arg1,_arg2);
11010
11011     wxPy_END_ALLOW_THREADS;
11012     if (PyErr_Occurred()) return NULL;
11013 }    Py_INCREF(Py_None);
11014     _resultobj = Py_None;
11015     return _resultobj;
11016 }
11017
11018 #define wxGrid_AutoSizeColumns(_swigobj,_swigarg0)  (_swigobj->AutoSizeColumns(_swigarg0))
11019 static PyObject *_wrap_wxGrid_AutoSizeColumns(PyObject *self, PyObject *args, PyObject *kwargs) {
11020     PyObject * _resultobj;
11021     wxGrid * _arg0;
11022     bool  _arg1 = (bool ) TRUE;
11023     PyObject * _argo0 = 0;
11024     int tempbool1 = (int) TRUE;
11025     char *_kwnames[] = { "self","setAsMin", NULL };
11026
11027     self = self;
11028     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeColumns",_kwnames,&_argo0,&tempbool1))
11029         return NULL;
11030     if (_argo0) {
11031         if (_argo0 == Py_None) { _arg0 = NULL; }
11032         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11033             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumns. Expected _wxGrid_p.");
11034         return NULL;
11035         }
11036     }
11037     _arg1 = (bool ) tempbool1;
11038 {
11039     wxPy_BEGIN_ALLOW_THREADS;
11040         wxGrid_AutoSizeColumns(_arg0,_arg1);
11041
11042     wxPy_END_ALLOW_THREADS;
11043     if (PyErr_Occurred()) return NULL;
11044 }    Py_INCREF(Py_None);
11045     _resultobj = Py_None;
11046     return _resultobj;
11047 }
11048
11049 #define wxGrid_AutoSizeRows(_swigobj,_swigarg0)  (_swigobj->AutoSizeRows(_swigarg0))
11050 static PyObject *_wrap_wxGrid_AutoSizeRows(PyObject *self, PyObject *args, PyObject *kwargs) {
11051     PyObject * _resultobj;
11052     wxGrid * _arg0;
11053     bool  _arg1 = (bool ) TRUE;
11054     PyObject * _argo0 = 0;
11055     int tempbool1 = (int) TRUE;
11056     char *_kwnames[] = { "self","setAsMin", NULL };
11057
11058     self = self;
11059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeRows",_kwnames,&_argo0,&tempbool1))
11060         return NULL;
11061     if (_argo0) {
11062         if (_argo0 == Py_None) { _arg0 = NULL; }
11063         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11064             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRows. Expected _wxGrid_p.");
11065         return NULL;
11066         }
11067     }
11068     _arg1 = (bool ) tempbool1;
11069 {
11070     wxPy_BEGIN_ALLOW_THREADS;
11071         wxGrid_AutoSizeRows(_arg0,_arg1);
11072
11073     wxPy_END_ALLOW_THREADS;
11074     if (PyErr_Occurred()) return NULL;
11075 }    Py_INCREF(Py_None);
11076     _resultobj = Py_None;
11077     return _resultobj;
11078 }
11079
11080 #define wxGrid_AutoSize(_swigobj)  (_swigobj->AutoSize())
11081 static PyObject *_wrap_wxGrid_AutoSize(PyObject *self, PyObject *args, PyObject *kwargs) {
11082     PyObject * _resultobj;
11083     wxGrid * _arg0;
11084     PyObject * _argo0 = 0;
11085     char *_kwnames[] = { "self", NULL };
11086
11087     self = self;
11088     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_AutoSize",_kwnames,&_argo0))
11089         return NULL;
11090     if (_argo0) {
11091         if (_argo0 == Py_None) { _arg0 = NULL; }
11092         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11093             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSize. Expected _wxGrid_p.");
11094         return NULL;
11095         }
11096     }
11097 {
11098     wxPy_BEGIN_ALLOW_THREADS;
11099         wxGrid_AutoSize(_arg0);
11100
11101     wxPy_END_ALLOW_THREADS;
11102     if (PyErr_Occurred()) return NULL;
11103 }    Py_INCREF(Py_None);
11104     _resultobj = Py_None;
11105     return _resultobj;
11106 }
11107
11108 #define wxGrid_SetColMinimalWidth(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColMinimalWidth(_swigarg0,_swigarg1))
11109 static PyObject *_wrap_wxGrid_SetColMinimalWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
11110     PyObject * _resultobj;
11111     wxGrid * _arg0;
11112     int  _arg1;
11113     int  _arg2;
11114     PyObject * _argo0 = 0;
11115     char *_kwnames[] = { "self","col","width", NULL };
11116
11117     self = self;
11118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColMinimalWidth",_kwnames,&_argo0,&_arg1,&_arg2))
11119         return NULL;
11120     if (_argo0) {
11121         if (_argo0 == Py_None) { _arg0 = NULL; }
11122         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11123             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColMinimalWidth. Expected _wxGrid_p.");
11124         return NULL;
11125         }
11126     }
11127 {
11128     wxPy_BEGIN_ALLOW_THREADS;
11129         wxGrid_SetColMinimalWidth(_arg0,_arg1,_arg2);
11130
11131     wxPy_END_ALLOW_THREADS;
11132     if (PyErr_Occurred()) return NULL;
11133 }    Py_INCREF(Py_None);
11134     _resultobj = Py_None;
11135     return _resultobj;
11136 }
11137
11138 #define wxGrid_SetRowMinimalHeight(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowMinimalHeight(_swigarg0,_swigarg1))
11139 static PyObject *_wrap_wxGrid_SetRowMinimalHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
11140     PyObject * _resultobj;
11141     wxGrid * _arg0;
11142     int  _arg1;
11143     int  _arg2;
11144     PyObject * _argo0 = 0;
11145     char *_kwnames[] = { "self","row","width", NULL };
11146
11147     self = self;
11148     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowMinimalHeight",_kwnames,&_argo0,&_arg1,&_arg2))
11149         return NULL;
11150     if (_argo0) {
11151         if (_argo0 == Py_None) { _arg0 = NULL; }
11152         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11153             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowMinimalHeight. Expected _wxGrid_p.");
11154         return NULL;
11155         }
11156     }
11157 {
11158     wxPy_BEGIN_ALLOW_THREADS;
11159         wxGrid_SetRowMinimalHeight(_arg0,_arg1,_arg2);
11160
11161     wxPy_END_ALLOW_THREADS;
11162     if (PyErr_Occurred()) return NULL;
11163 }    Py_INCREF(Py_None);
11164     _resultobj = Py_None;
11165     return _resultobj;
11166 }
11167
11168 #define wxGrid_SetDefaultCellBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellBackgroundColour(_swigarg0))
11169 static PyObject *_wrap_wxGrid_SetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11170     PyObject * _resultobj;
11171     wxGrid * _arg0;
11172     wxColour * _arg1;
11173     PyObject * _argo0 = 0;
11174     wxColour  temp;
11175     PyObject * _obj1 = 0;
11176     char *_kwnames[] = { "self","arg2", NULL };
11177
11178     self = self;
11179     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellBackgroundColour",_kwnames,&_argo0,&_obj1))
11180         return NULL;
11181     if (_argo0) {
11182         if (_argo0 == Py_None) { _arg0 = NULL; }
11183         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11184             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellBackgroundColour. Expected _wxGrid_p.");
11185         return NULL;
11186         }
11187     }
11188 {
11189     _arg1 = &temp;
11190     if (! wxColour_helper(_obj1, &_arg1))
11191         return NULL;
11192 }
11193 {
11194     wxPy_BEGIN_ALLOW_THREADS;
11195         wxGrid_SetDefaultCellBackgroundColour(_arg0,*_arg1);
11196
11197     wxPy_END_ALLOW_THREADS;
11198     if (PyErr_Occurred()) return NULL;
11199 }    Py_INCREF(Py_None);
11200     _resultobj = Py_None;
11201     return _resultobj;
11202 }
11203
11204 #define wxGrid_SetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellBackgroundColour(_swigarg0,_swigarg1,_swigarg2))
11205 static PyObject *_wrap_wxGrid_SetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11206     PyObject * _resultobj;
11207     wxGrid * _arg0;
11208     int  _arg1;
11209     int  _arg2;
11210     wxColour * _arg3;
11211     PyObject * _argo0 = 0;
11212     wxColour  temp;
11213     PyObject * _obj3 = 0;
11214     char *_kwnames[] = { "self","row","col","arg4", NULL };
11215
11216     self = self;
11217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11218         return NULL;
11219     if (_argo0) {
11220         if (_argo0 == Py_None) { _arg0 = NULL; }
11221         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11222             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellBackgroundColour. Expected _wxGrid_p.");
11223         return NULL;
11224         }
11225     }
11226 {
11227     _arg3 = &temp;
11228     if (! wxColour_helper(_obj3, &_arg3))
11229         return NULL;
11230 }
11231 {
11232     wxPy_BEGIN_ALLOW_THREADS;
11233         wxGrid_SetCellBackgroundColour(_arg0,_arg1,_arg2,*_arg3);
11234
11235     wxPy_END_ALLOW_THREADS;
11236     if (PyErr_Occurred()) return NULL;
11237 }    Py_INCREF(Py_None);
11238     _resultobj = Py_None;
11239     return _resultobj;
11240 }
11241
11242 #define wxGrid_SetDefaultCellTextColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellTextColour(_swigarg0))
11243 static PyObject *_wrap_wxGrid_SetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11244     PyObject * _resultobj;
11245     wxGrid * _arg0;
11246     wxColour * _arg1;
11247     PyObject * _argo0 = 0;
11248     wxColour  temp;
11249     PyObject * _obj1 = 0;
11250     char *_kwnames[] = { "self","arg2", NULL };
11251
11252     self = self;
11253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellTextColour",_kwnames,&_argo0,&_obj1))
11254         return NULL;
11255     if (_argo0) {
11256         if (_argo0 == Py_None) { _arg0 = NULL; }
11257         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11258             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellTextColour. Expected _wxGrid_p.");
11259         return NULL;
11260         }
11261     }
11262 {
11263     _arg1 = &temp;
11264     if (! wxColour_helper(_obj1, &_arg1))
11265         return NULL;
11266 }
11267 {
11268     wxPy_BEGIN_ALLOW_THREADS;
11269         wxGrid_SetDefaultCellTextColour(_arg0,*_arg1);
11270
11271     wxPy_END_ALLOW_THREADS;
11272     if (PyErr_Occurred()) return NULL;
11273 }    Py_INCREF(Py_None);
11274     _resultobj = Py_None;
11275     return _resultobj;
11276 }
11277
11278 #define wxGrid_SetCellTextColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellTextColour(_swigarg0,_swigarg1,_swigarg2))
11279 static PyObject *_wrap_wxGrid_SetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11280     PyObject * _resultobj;
11281     wxGrid * _arg0;
11282     int  _arg1;
11283     int  _arg2;
11284     wxColour * _arg3;
11285     PyObject * _argo0 = 0;
11286     wxColour  temp;
11287     PyObject * _obj3 = 0;
11288     char *_kwnames[] = { "self","row","col","arg4", NULL };
11289
11290     self = self;
11291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11292         return NULL;
11293     if (_argo0) {
11294         if (_argo0 == Py_None) { _arg0 = NULL; }
11295         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11296             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellTextColour. Expected _wxGrid_p.");
11297         return NULL;
11298         }
11299     }
11300 {
11301     _arg3 = &temp;
11302     if (! wxColour_helper(_obj3, &_arg3))
11303         return NULL;
11304 }
11305 {
11306     wxPy_BEGIN_ALLOW_THREADS;
11307         wxGrid_SetCellTextColour(_arg0,_arg1,_arg2,*_arg3);
11308
11309     wxPy_END_ALLOW_THREADS;
11310     if (PyErr_Occurred()) return NULL;
11311 }    Py_INCREF(Py_None);
11312     _resultobj = Py_None;
11313     return _resultobj;
11314 }
11315
11316 #define wxGrid_SetDefaultCellFont(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellFont(_swigarg0))
11317 static PyObject *_wrap_wxGrid_SetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11318     PyObject * _resultobj;
11319     wxGrid * _arg0;
11320     wxFont * _arg1;
11321     PyObject * _argo0 = 0;
11322     PyObject * _argo1 = 0;
11323     char *_kwnames[] = { "self","arg2", NULL };
11324
11325     self = self;
11326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellFont",_kwnames,&_argo0,&_argo1))
11327         return NULL;
11328     if (_argo0) {
11329         if (_argo0 == Py_None) { _arg0 = NULL; }
11330         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11331             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellFont. Expected _wxGrid_p.");
11332         return NULL;
11333         }
11334     }
11335     if (_argo1) {
11336         if (_argo1 == Py_None) { _arg1 = NULL; }
11337         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
11338             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultCellFont. Expected _wxFont_p.");
11339         return NULL;
11340         }
11341     }
11342 {
11343     wxPy_BEGIN_ALLOW_THREADS;
11344         wxGrid_SetDefaultCellFont(_arg0,*_arg1);
11345
11346     wxPy_END_ALLOW_THREADS;
11347     if (PyErr_Occurred()) return NULL;
11348 }    Py_INCREF(Py_None);
11349     _resultobj = Py_None;
11350     return _resultobj;
11351 }
11352
11353 #define wxGrid_SetCellFont(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellFont(_swigarg0,_swigarg1,_swigarg2))
11354 static PyObject *_wrap_wxGrid_SetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11355     PyObject * _resultobj;
11356     wxGrid * _arg0;
11357     int  _arg1;
11358     int  _arg2;
11359     wxFont * _arg3;
11360     PyObject * _argo0 = 0;
11361     PyObject * _argo3 = 0;
11362     char *_kwnames[] = { "self","row","col","arg4", NULL };
11363
11364     self = self;
11365     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellFont",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11366         return NULL;
11367     if (_argo0) {
11368         if (_argo0 == Py_None) { _arg0 = NULL; }
11369         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11370             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellFont. Expected _wxGrid_p.");
11371         return NULL;
11372         }
11373     }
11374     if (_argo3) {
11375         if (_argo3 == Py_None) { _arg3 = NULL; }
11376         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxFont_p")) {
11377             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellFont. Expected _wxFont_p.");
11378         return NULL;
11379         }
11380     }
11381 {
11382     wxPy_BEGIN_ALLOW_THREADS;
11383         wxGrid_SetCellFont(_arg0,_arg1,_arg2,*_arg3);
11384
11385     wxPy_END_ALLOW_THREADS;
11386     if (PyErr_Occurred()) return NULL;
11387 }    Py_INCREF(Py_None);
11388     _resultobj = Py_None;
11389     return _resultobj;
11390 }
11391
11392 #define wxGrid_SetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultCellAlignment(_swigarg0,_swigarg1))
11393 static PyObject *_wrap_wxGrid_SetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11394     PyObject * _resultobj;
11395     wxGrid * _arg0;
11396     int  _arg1;
11397     int  _arg2;
11398     PyObject * _argo0 = 0;
11399     char *_kwnames[] = { "self","horiz","vert", NULL };
11400
11401     self = self;
11402     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetDefaultCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
11403         return NULL;
11404     if (_argo0) {
11405         if (_argo0 == Py_None) { _arg0 = NULL; }
11406         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11407             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellAlignment. Expected _wxGrid_p.");
11408         return NULL;
11409         }
11410     }
11411 {
11412     wxPy_BEGIN_ALLOW_THREADS;
11413         wxGrid_SetDefaultCellAlignment(_arg0,_arg1,_arg2);
11414
11415     wxPy_END_ALLOW_THREADS;
11416     if (PyErr_Occurred()) return NULL;
11417 }    Py_INCREF(Py_None);
11418     _resultobj = Py_None;
11419     return _resultobj;
11420 }
11421
11422 #define wxGrid_SetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->SetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
11423 static PyObject *_wrap_wxGrid_SetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11424     PyObject * _resultobj;
11425     wxGrid * _arg0;
11426     int  _arg1;
11427     int  _arg2;
11428     int  _arg3;
11429     int  _arg4;
11430     PyObject * _argo0 = 0;
11431     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
11432
11433     self = self;
11434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxGrid_SetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4))
11435         return NULL;
11436     if (_argo0) {
11437         if (_argo0 == Py_None) { _arg0 = NULL; }
11438         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11439             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellAlignment. Expected _wxGrid_p.");
11440         return NULL;
11441         }
11442     }
11443 {
11444     wxPy_BEGIN_ALLOW_THREADS;
11445         wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
11446
11447     wxPy_END_ALLOW_THREADS;
11448     if (PyErr_Occurred()) return NULL;
11449 }    Py_INCREF(Py_None);
11450     _resultobj = Py_None;
11451     return _resultobj;
11452 }
11453
11454 #define wxGrid_SetDefaultRenderer(_swigobj,_swigarg0)  (_swigobj->SetDefaultRenderer(_swigarg0))
11455 static PyObject *_wrap_wxGrid_SetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11456     PyObject * _resultobj;
11457     wxGrid * _arg0;
11458     wxGridCellRenderer * _arg1;
11459     PyObject * _argo0 = 0;
11460     PyObject * _argo1 = 0;
11461     char *_kwnames[] = { "self","renderer", NULL };
11462
11463     self = self;
11464     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultRenderer",_kwnames,&_argo0,&_argo1))
11465         return NULL;
11466     if (_argo0) {
11467         if (_argo0 == Py_None) { _arg0 = NULL; }
11468         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11469             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRenderer. Expected _wxGrid_p.");
11470         return NULL;
11471         }
11472     }
11473     if (_argo1) {
11474         if (_argo1 == Py_None) { _arg1 = NULL; }
11475         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellRenderer_p")) {
11476             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultRenderer. Expected _wxGridCellRenderer_p.");
11477         return NULL;
11478         }
11479     }
11480 {
11481     wxPy_BEGIN_ALLOW_THREADS;
11482         wxGrid_SetDefaultRenderer(_arg0,_arg1);
11483
11484     wxPy_END_ALLOW_THREADS;
11485     if (PyErr_Occurred()) return NULL;
11486 }    Py_INCREF(Py_None);
11487     _resultobj = Py_None;
11488     return _resultobj;
11489 }
11490
11491 #define wxGrid_SetCellRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellRenderer(_swigarg0,_swigarg1,_swigarg2))
11492 static PyObject *_wrap_wxGrid_SetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11493     PyObject * _resultobj;
11494     wxGrid * _arg0;
11495     int  _arg1;
11496     int  _arg2;
11497     wxGridCellRenderer * _arg3;
11498     PyObject * _argo0 = 0;
11499     PyObject * _argo3 = 0;
11500     char *_kwnames[] = { "self","row","col","renderer", NULL };
11501
11502     self = self;
11503     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11504         return NULL;
11505     if (_argo0) {
11506         if (_argo0 == Py_None) { _arg0 = NULL; }
11507         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11508             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellRenderer. Expected _wxGrid_p.");
11509         return NULL;
11510         }
11511     }
11512     if (_argo3) {
11513         if (_argo3 == Py_None) { _arg3 = NULL; }
11514         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellRenderer_p")) {
11515             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellRenderer. Expected _wxGridCellRenderer_p.");
11516         return NULL;
11517         }
11518     }
11519 {
11520     wxPy_BEGIN_ALLOW_THREADS;
11521         wxGrid_SetCellRenderer(_arg0,_arg1,_arg2,_arg3);
11522
11523     wxPy_END_ALLOW_THREADS;
11524     if (PyErr_Occurred()) return NULL;
11525 }    Py_INCREF(Py_None);
11526     _resultobj = Py_None;
11527     return _resultobj;
11528 }
11529
11530 #define wxGrid_GetDefaultRenderer(_swigobj)  (_swigobj->GetDefaultRenderer())
11531 static PyObject *_wrap_wxGrid_GetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11532     PyObject * _resultobj;
11533     wxGridCellRenderer * _result;
11534     wxGrid * _arg0;
11535     PyObject * _argo0 = 0;
11536     char *_kwnames[] = { "self", NULL };
11537     char _ptemp[128];
11538
11539     self = self;
11540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRenderer",_kwnames,&_argo0))
11541         return NULL;
11542     if (_argo0) {
11543         if (_argo0 == Py_None) { _arg0 = NULL; }
11544         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11545             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRenderer. Expected _wxGrid_p.");
11546         return NULL;
11547         }
11548     }
11549 {
11550     wxPy_BEGIN_ALLOW_THREADS;
11551         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRenderer(_arg0);
11552
11553     wxPy_END_ALLOW_THREADS;
11554     if (PyErr_Occurred()) return NULL;
11555 }    if (_result) {
11556         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11557         _resultobj = Py_BuildValue("s",_ptemp);
11558     } else {
11559         Py_INCREF(Py_None);
11560         _resultobj = Py_None;
11561     }
11562     return _resultobj;
11563 }
11564
11565 #define wxGrid_GetCellRenderer(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellRenderer(_swigarg0,_swigarg1))
11566 static PyObject *_wrap_wxGrid_GetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11567     PyObject * _resultobj;
11568     wxGridCellRenderer * _result;
11569     wxGrid * _arg0;
11570     int  _arg1;
11571     int  _arg2;
11572     PyObject * _argo0 = 0;
11573     char *_kwnames[] = { "self","row","col", NULL };
11574     char _ptemp[128];
11575
11576     self = self;
11577     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2))
11578         return NULL;
11579     if (_argo0) {
11580         if (_argo0 == Py_None) { _arg0 = NULL; }
11581         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11582             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellRenderer. Expected _wxGrid_p.");
11583         return NULL;
11584         }
11585     }
11586 {
11587     wxPy_BEGIN_ALLOW_THREADS;
11588         _result = (wxGridCellRenderer *)wxGrid_GetCellRenderer(_arg0,_arg1,_arg2);
11589
11590     wxPy_END_ALLOW_THREADS;
11591     if (PyErr_Occurred()) return NULL;
11592 }    if (_result) {
11593         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11594         _resultobj = Py_BuildValue("s",_ptemp);
11595     } else {
11596         Py_INCREF(Py_None);
11597         _resultobj = Py_None;
11598     }
11599     return _resultobj;
11600 }
11601
11602 #define wxGrid_SetDefaultEditor(_swigobj,_swigarg0)  (_swigobj->SetDefaultEditor(_swigarg0))
11603 static PyObject *_wrap_wxGrid_SetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11604     PyObject * _resultobj;
11605     wxGrid * _arg0;
11606     wxGridCellEditor * _arg1;
11607     PyObject * _argo0 = 0;
11608     PyObject * _argo1 = 0;
11609     char *_kwnames[] = { "self","editor", NULL };
11610
11611     self = self;
11612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultEditor",_kwnames,&_argo0,&_argo1))
11613         return NULL;
11614     if (_argo0) {
11615         if (_argo0 == Py_None) { _arg0 = NULL; }
11616         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11617             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultEditor. Expected _wxGrid_p.");
11618         return NULL;
11619         }
11620     }
11621     if (_argo1) {
11622         if (_argo1 == Py_None) { _arg1 = NULL; }
11623         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellEditor_p")) {
11624             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultEditor. Expected _wxGridCellEditor_p.");
11625         return NULL;
11626         }
11627     }
11628 {
11629     wxPy_BEGIN_ALLOW_THREADS;
11630         wxGrid_SetDefaultEditor(_arg0,_arg1);
11631
11632     wxPy_END_ALLOW_THREADS;
11633     if (PyErr_Occurred()) return NULL;
11634 }    Py_INCREF(Py_None);
11635     _resultobj = Py_None;
11636     return _resultobj;
11637 }
11638
11639 #define wxGrid_SetCellEditor(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellEditor(_swigarg0,_swigarg1,_swigarg2))
11640 static PyObject *_wrap_wxGrid_SetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11641     PyObject * _resultobj;
11642     wxGrid * _arg0;
11643     int  _arg1;
11644     int  _arg2;
11645     wxGridCellEditor * _arg3;
11646     PyObject * _argo0 = 0;
11647     PyObject * _argo3 = 0;
11648     char *_kwnames[] = { "self","row","col","editor", NULL };
11649
11650     self = self;
11651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11652         return NULL;
11653     if (_argo0) {
11654         if (_argo0 == Py_None) { _arg0 = NULL; }
11655         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11656             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellEditor. Expected _wxGrid_p.");
11657         return NULL;
11658         }
11659     }
11660     if (_argo3) {
11661         if (_argo3 == Py_None) { _arg3 = NULL; }
11662         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
11663             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellEditor. Expected _wxGridCellEditor_p.");
11664         return NULL;
11665         }
11666     }
11667 {
11668     wxPy_BEGIN_ALLOW_THREADS;
11669         wxGrid_SetCellEditor(_arg0,_arg1,_arg2,_arg3);
11670
11671     wxPy_END_ALLOW_THREADS;
11672     if (PyErr_Occurred()) return NULL;
11673 }    Py_INCREF(Py_None);
11674     _resultobj = Py_None;
11675     return _resultobj;
11676 }
11677
11678 #define wxGrid_GetDefaultEditor(_swigobj)  (_swigobj->GetDefaultEditor())
11679 static PyObject *_wrap_wxGrid_GetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11680     PyObject * _resultobj;
11681     wxGridCellEditor * _result;
11682     wxGrid * _arg0;
11683     PyObject * _argo0 = 0;
11684     char *_kwnames[] = { "self", NULL };
11685     char _ptemp[128];
11686
11687     self = self;
11688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultEditor",_kwnames,&_argo0))
11689         return NULL;
11690     if (_argo0) {
11691         if (_argo0 == Py_None) { _arg0 = NULL; }
11692         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11693             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditor. Expected _wxGrid_p.");
11694         return NULL;
11695         }
11696     }
11697 {
11698     wxPy_BEGIN_ALLOW_THREADS;
11699         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditor(_arg0);
11700
11701     wxPy_END_ALLOW_THREADS;
11702     if (PyErr_Occurred()) return NULL;
11703 }    if (_result) {
11704         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11705         _resultobj = Py_BuildValue("s",_ptemp);
11706     } else {
11707         Py_INCREF(Py_None);
11708         _resultobj = Py_None;
11709     }
11710     return _resultobj;
11711 }
11712
11713 #define wxGrid_GetCellEditor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellEditor(_swigarg0,_swigarg1))
11714 static PyObject *_wrap_wxGrid_GetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11715     PyObject * _resultobj;
11716     wxGridCellEditor * _result;
11717     wxGrid * _arg0;
11718     int  _arg1;
11719     int  _arg2;
11720     PyObject * _argo0 = 0;
11721     char *_kwnames[] = { "self","row","col", NULL };
11722     char _ptemp[128];
11723
11724     self = self;
11725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2))
11726         return NULL;
11727     if (_argo0) {
11728         if (_argo0 == Py_None) { _arg0 = NULL; }
11729         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11730             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellEditor. Expected _wxGrid_p.");
11731         return NULL;
11732         }
11733     }
11734 {
11735     wxPy_BEGIN_ALLOW_THREADS;
11736         _result = (wxGridCellEditor *)wxGrid_GetCellEditor(_arg0,_arg1,_arg2);
11737
11738     wxPy_END_ALLOW_THREADS;
11739     if (PyErr_Occurred()) return NULL;
11740 }    if (_result) {
11741         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11742         _resultobj = Py_BuildValue("s",_ptemp);
11743     } else {
11744         Py_INCREF(Py_None);
11745         _resultobj = Py_None;
11746     }
11747     return _resultobj;
11748 }
11749
11750 #define wxGrid_GetCellValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellValue(_swigarg0,_swigarg1))
11751 static PyObject *_wrap_wxGrid_GetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11752     PyObject * _resultobj;
11753     wxString * _result;
11754     wxGrid * _arg0;
11755     int  _arg1;
11756     int  _arg2;
11757     PyObject * _argo0 = 0;
11758     char *_kwnames[] = { "self","row","col", NULL };
11759
11760     self = self;
11761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellValue",_kwnames,&_argo0,&_arg1,&_arg2))
11762         return NULL;
11763     if (_argo0) {
11764         if (_argo0 == Py_None) { _arg0 = NULL; }
11765         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11766             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellValue. Expected _wxGrid_p.");
11767         return NULL;
11768         }
11769     }
11770 {
11771     wxPy_BEGIN_ALLOW_THREADS;
11772         _result = new wxString (wxGrid_GetCellValue(_arg0,_arg1,_arg2));
11773
11774     wxPy_END_ALLOW_THREADS;
11775     if (PyErr_Occurred()) return NULL;
11776 }{
11777     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
11778 }
11779 {
11780     delete _result;
11781 }
11782     return _resultobj;
11783 }
11784
11785 #define wxGrid_SetCellValue(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellValue(_swigarg0,_swigarg1,_swigarg2))
11786 static PyObject *_wrap_wxGrid_SetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11787     PyObject * _resultobj;
11788     wxGrid * _arg0;
11789     int  _arg1;
11790     int  _arg2;
11791     wxString * _arg3;
11792     PyObject * _argo0 = 0;
11793     PyObject * _obj3 = 0;
11794     char *_kwnames[] = { "self","row","col","s", NULL };
11795
11796     self = self;
11797     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellValue",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11798         return NULL;
11799     if (_argo0) {
11800         if (_argo0 == Py_None) { _arg0 = NULL; }
11801         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11802             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellValue. Expected _wxGrid_p.");
11803         return NULL;
11804         }
11805     }
11806 {
11807 #if PYTHON_API_VERSION >= 1009
11808     char* tmpPtr; int tmpSize;
11809     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
11810         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11811         return NULL;
11812     }
11813     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
11814         return NULL;
11815     _arg3 = new wxString(tmpPtr, tmpSize);
11816 #else
11817     if (!PyString_Check(_obj3)) {
11818         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11819         return NULL;
11820     }
11821     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
11822 #endif
11823 }
11824 {
11825     wxPy_BEGIN_ALLOW_THREADS;
11826         wxGrid_SetCellValue(_arg0,_arg1,_arg2,*_arg3);
11827
11828     wxPy_END_ALLOW_THREADS;
11829     if (PyErr_Occurred()) return NULL;
11830 }    Py_INCREF(Py_None);
11831     _resultobj = Py_None;
11832 {
11833     if (_obj3)
11834         delete _arg3;
11835 }
11836     return _resultobj;
11837 }
11838
11839 #define wxGrid_IsReadOnly(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsReadOnly(_swigarg0,_swigarg1))
11840 static PyObject *_wrap_wxGrid_IsReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11841     PyObject * _resultobj;
11842     bool  _result;
11843     wxGrid * _arg0;
11844     int  _arg1;
11845     int  _arg2;
11846     PyObject * _argo0 = 0;
11847     char *_kwnames[] = { "self","row","col", NULL };
11848
11849     self = self;
11850     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsReadOnly",_kwnames,&_argo0,&_arg1,&_arg2))
11851         return NULL;
11852     if (_argo0) {
11853         if (_argo0 == Py_None) { _arg0 = NULL; }
11854         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11855             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsReadOnly. Expected _wxGrid_p.");
11856         return NULL;
11857         }
11858     }
11859 {
11860     wxPy_BEGIN_ALLOW_THREADS;
11861         _result = (bool )wxGrid_IsReadOnly(_arg0,_arg1,_arg2);
11862
11863     wxPy_END_ALLOW_THREADS;
11864     if (PyErr_Occurred()) return NULL;
11865 }    _resultobj = Py_BuildValue("i",_result);
11866     return _resultobj;
11867 }
11868
11869 #define wxGrid_SetReadOnly(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetReadOnly(_swigarg0,_swigarg1,_swigarg2))
11870 static PyObject *_wrap_wxGrid_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11871     PyObject * _resultobj;
11872     wxGrid * _arg0;
11873     int  _arg1;
11874     int  _arg2;
11875     bool  _arg3 = (bool ) TRUE;
11876     PyObject * _argo0 = 0;
11877     int tempbool3 = (int) TRUE;
11878     char *_kwnames[] = { "self","row","col","isReadOnly", NULL };
11879
11880     self = self;
11881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_SetReadOnly",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
11882         return NULL;
11883     if (_argo0) {
11884         if (_argo0 == Py_None) { _arg0 = NULL; }
11885         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11886             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetReadOnly. Expected _wxGrid_p.");
11887         return NULL;
11888         }
11889     }
11890     _arg3 = (bool ) tempbool3;
11891 {
11892     wxPy_BEGIN_ALLOW_THREADS;
11893         wxGrid_SetReadOnly(_arg0,_arg1,_arg2,_arg3);
11894
11895     wxPy_END_ALLOW_THREADS;
11896     if (PyErr_Occurred()) return NULL;
11897 }    Py_INCREF(Py_None);
11898     _resultobj = Py_None;
11899     return _resultobj;
11900 }
11901
11902 #define wxGrid_SelectRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectRow(_swigarg0,_swigarg1))
11903 static PyObject *_wrap_wxGrid_SelectRow(PyObject *self, PyObject *args, PyObject *kwargs) {
11904     PyObject * _resultobj;
11905     wxGrid * _arg0;
11906     int  _arg1;
11907     bool  _arg2 = (bool ) FALSE;
11908     PyObject * _argo0 = 0;
11909     int tempbool2 = (int) FALSE;
11910     char *_kwnames[] = { "self","row","addToSelected", NULL };
11911
11912     self = self;
11913     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectRow",_kwnames,&_argo0,&_arg1,&tempbool2))
11914         return NULL;
11915     if (_argo0) {
11916         if (_argo0 == Py_None) { _arg0 = NULL; }
11917         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11918             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectRow. Expected _wxGrid_p.");
11919         return NULL;
11920         }
11921     }
11922     _arg2 = (bool ) tempbool2;
11923 {
11924     wxPy_BEGIN_ALLOW_THREADS;
11925         wxGrid_SelectRow(_arg0,_arg1,_arg2);
11926
11927     wxPy_END_ALLOW_THREADS;
11928     if (PyErr_Occurred()) return NULL;
11929 }    Py_INCREF(Py_None);
11930     _resultobj = Py_None;
11931     return _resultobj;
11932 }
11933
11934 #define wxGrid_SelectCol(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectCol(_swigarg0,_swigarg1))
11935 static PyObject *_wrap_wxGrid_SelectCol(PyObject *self, PyObject *args, PyObject *kwargs) {
11936     PyObject * _resultobj;
11937     wxGrid * _arg0;
11938     int  _arg1;
11939     bool  _arg2 = (bool ) FALSE;
11940     PyObject * _argo0 = 0;
11941     int tempbool2 = (int) FALSE;
11942     char *_kwnames[] = { "self","col","addToSelected", NULL };
11943
11944     self = self;
11945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectCol",_kwnames,&_argo0,&_arg1,&tempbool2))
11946         return NULL;
11947     if (_argo0) {
11948         if (_argo0 == Py_None) { _arg0 = NULL; }
11949         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11950             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectCol. Expected _wxGrid_p.");
11951         return NULL;
11952         }
11953     }
11954     _arg2 = (bool ) tempbool2;
11955 {
11956     wxPy_BEGIN_ALLOW_THREADS;
11957         wxGrid_SelectCol(_arg0,_arg1,_arg2);
11958
11959     wxPy_END_ALLOW_THREADS;
11960     if (PyErr_Occurred()) return NULL;
11961 }    Py_INCREF(Py_None);
11962     _resultobj = Py_None;
11963     return _resultobj;
11964 }
11965
11966 #define wxGrid_SelectBlock(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SelectBlock(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
11967 static PyObject *_wrap_wxGrid_SelectBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
11968     PyObject * _resultobj;
11969     wxGrid * _arg0;
11970     int  _arg1;
11971     int  _arg2;
11972     int  _arg3;
11973     int  _arg4;
11974     bool  _arg5 = (bool ) FALSE;
11975     PyObject * _argo0 = 0;
11976     int tempbool5 = (int) FALSE;
11977     char *_kwnames[] = { "self","topRow","leftCol","bottomRow","rightCol","addToSelected", NULL };
11978
11979     self = self;
11980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|i:wxGrid_SelectBlock",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&tempbool5))
11981         return NULL;
11982     if (_argo0) {
11983         if (_argo0 == Py_None) { _arg0 = NULL; }
11984         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11985             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectBlock. Expected _wxGrid_p.");
11986         return NULL;
11987         }
11988     }
11989     _arg5 = (bool ) tempbool5;
11990 {
11991     wxPy_BEGIN_ALLOW_THREADS;
11992         wxGrid_SelectBlock(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
11993
11994     wxPy_END_ALLOW_THREADS;
11995     if (PyErr_Occurred()) return NULL;
11996 }    Py_INCREF(Py_None);
11997     _resultobj = Py_None;
11998     return _resultobj;
11999 }
12000
12001 #define wxGrid_SelectAll(_swigobj)  (_swigobj->SelectAll())
12002 static PyObject *_wrap_wxGrid_SelectAll(PyObject *self, PyObject *args, PyObject *kwargs) {
12003     PyObject * _resultobj;
12004     wxGrid * _arg0;
12005     PyObject * _argo0 = 0;
12006     char *_kwnames[] = { "self", NULL };
12007
12008     self = self;
12009     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SelectAll",_kwnames,&_argo0))
12010         return NULL;
12011     if (_argo0) {
12012         if (_argo0 == Py_None) { _arg0 = NULL; }
12013         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12014             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectAll. Expected _wxGrid_p.");
12015         return NULL;
12016         }
12017     }
12018 {
12019     wxPy_BEGIN_ALLOW_THREADS;
12020         wxGrid_SelectAll(_arg0);
12021
12022     wxPy_END_ALLOW_THREADS;
12023     if (PyErr_Occurred()) return NULL;
12024 }    Py_INCREF(Py_None);
12025     _resultobj = Py_None;
12026     return _resultobj;
12027 }
12028
12029 #define wxGrid_IsSelection(_swigobj)  (_swigobj->IsSelection())
12030 static PyObject *_wrap_wxGrid_IsSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12031     PyObject * _resultobj;
12032     bool  _result;
12033     wxGrid * _arg0;
12034     PyObject * _argo0 = 0;
12035     char *_kwnames[] = { "self", NULL };
12036
12037     self = self;
12038     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsSelection",_kwnames,&_argo0))
12039         return NULL;
12040     if (_argo0) {
12041         if (_argo0 == Py_None) { _arg0 = NULL; }
12042         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12043             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsSelection. Expected _wxGrid_p.");
12044         return NULL;
12045         }
12046     }
12047 {
12048     wxPy_BEGIN_ALLOW_THREADS;
12049         _result = (bool )wxGrid_IsSelection(_arg0);
12050
12051     wxPy_END_ALLOW_THREADS;
12052     if (PyErr_Occurred()) return NULL;
12053 }    _resultobj = Py_BuildValue("i",_result);
12054     return _resultobj;
12055 }
12056
12057 #define wxGrid_ClearSelection(_swigobj)  (_swigobj->ClearSelection())
12058 static PyObject *_wrap_wxGrid_ClearSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12059     PyObject * _resultobj;
12060     wxGrid * _arg0;
12061     PyObject * _argo0 = 0;
12062     char *_kwnames[] = { "self", NULL };
12063
12064     self = self;
12065     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ClearSelection",_kwnames,&_argo0))
12066         return NULL;
12067     if (_argo0) {
12068         if (_argo0 == Py_None) { _arg0 = NULL; }
12069         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12070             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ClearSelection. Expected _wxGrid_p.");
12071         return NULL;
12072         }
12073     }
12074 {
12075     wxPy_BEGIN_ALLOW_THREADS;
12076         wxGrid_ClearSelection(_arg0);
12077
12078     wxPy_END_ALLOW_THREADS;
12079     if (PyErr_Occurred()) return NULL;
12080 }    Py_INCREF(Py_None);
12081     _resultobj = Py_None;
12082     return _resultobj;
12083 }
12084
12085 #define wxGrid_IsInSelection(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsInSelection(_swigarg0,_swigarg1))
12086 static PyObject *_wrap_wxGrid_IsInSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12087     PyObject * _resultobj;
12088     bool  _result;
12089     wxGrid * _arg0;
12090     int  _arg1;
12091     int  _arg2;
12092     PyObject * _argo0 = 0;
12093     char *_kwnames[] = { "self","row","col", NULL };
12094
12095     self = self;
12096     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsInSelection",_kwnames,&_argo0,&_arg1,&_arg2))
12097         return NULL;
12098     if (_argo0) {
12099         if (_argo0 == Py_None) { _arg0 = NULL; }
12100         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12101             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsInSelection. Expected _wxGrid_p.");
12102         return NULL;
12103         }
12104     }
12105 {
12106     wxPy_BEGIN_ALLOW_THREADS;
12107         _result = (bool )wxGrid_IsInSelection(_arg0,_arg1,_arg2);
12108
12109     wxPy_END_ALLOW_THREADS;
12110     if (PyErr_Occurred()) return NULL;
12111 }    _resultobj = Py_BuildValue("i",_result);
12112     return _resultobj;
12113 }
12114
12115 #define wxGrid_BlockToDeviceRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->BlockToDeviceRect(_swigarg0,_swigarg1))
12116 static PyObject *_wrap_wxGrid_BlockToDeviceRect(PyObject *self, PyObject *args, PyObject *kwargs) {
12117     PyObject * _resultobj;
12118     wxRect * _result;
12119     wxGrid * _arg0;
12120     wxGridCellCoords * _arg1;
12121     wxGridCellCoords * _arg2;
12122     PyObject * _argo0 = 0;
12123     wxGridCellCoords  temp;
12124     PyObject * _obj1 = 0;
12125     wxGridCellCoords  temp0;
12126     PyObject * _obj2 = 0;
12127     char *_kwnames[] = { "self","topLeft","bottomRight", NULL };
12128     char _ptemp[128];
12129
12130     self = self;
12131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_BlockToDeviceRect",_kwnames,&_argo0,&_obj1,&_obj2))
12132         return NULL;
12133     if (_argo0) {
12134         if (_argo0 == Py_None) { _arg0 = NULL; }
12135         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12136             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BlockToDeviceRect. Expected _wxGrid_p.");
12137         return NULL;
12138         }
12139     }
12140 {
12141     _arg1 = &temp;
12142     if (! wxGridCellCoords_helper(_obj1, &_arg1))
12143         return NULL;
12144 }
12145 {
12146     _arg2 = &temp0;
12147     if (! wxGridCellCoords_helper(_obj2, &_arg2))
12148         return NULL;
12149 }
12150 {
12151     wxPy_BEGIN_ALLOW_THREADS;
12152         _result = new wxRect (wxGrid_BlockToDeviceRect(_arg0,*_arg1,*_arg2));
12153
12154     wxPy_END_ALLOW_THREADS;
12155     if (PyErr_Occurred()) return NULL;
12156 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
12157     _resultobj = Py_BuildValue("s",_ptemp);
12158     return _resultobj;
12159 }
12160
12161 #define wxGrid_GetSelectionBackground(_swigobj)  (_swigobj->GetSelectionBackground())
12162 static PyObject *_wrap_wxGrid_GetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12163     PyObject * _resultobj;
12164     wxColour * _result;
12165     wxGrid * _arg0;
12166     PyObject * _argo0 = 0;
12167     char *_kwnames[] = { "self", NULL };
12168     char _ptemp[128];
12169
12170     self = self;
12171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionBackground",_kwnames,&_argo0))
12172         return NULL;
12173     if (_argo0) {
12174         if (_argo0 == Py_None) { _arg0 = NULL; }
12175         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12176             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetSelectionBackground. Expected _wxGrid_p.");
12177         return NULL;
12178         }
12179     }
12180 {
12181     wxPy_BEGIN_ALLOW_THREADS;
12182         _result = new wxColour (wxGrid_GetSelectionBackground(_arg0));
12183
12184     wxPy_END_ALLOW_THREADS;
12185     if (PyErr_Occurred()) return NULL;
12186 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12187     _resultobj = Py_BuildValue("s",_ptemp);
12188     return _resultobj;
12189 }
12190
12191 #define wxGrid_GetSelectionForeground(_swigobj)  (_swigobj->GetSelectionForeground())
12192 static PyObject *_wrap_wxGrid_GetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12193     PyObject * _resultobj;
12194     wxColour * _result;
12195     wxGrid * _arg0;
12196     PyObject * _argo0 = 0;
12197     char *_kwnames[] = { "self", NULL };
12198     char _ptemp[128];
12199
12200     self = self;
12201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionForeground",_kwnames,&_argo0))
12202         return NULL;
12203     if (_argo0) {
12204         if (_argo0 == Py_None) { _arg0 = NULL; }
12205         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12206             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetSelectionForeground. Expected _wxGrid_p.");
12207         return NULL;
12208         }
12209     }
12210 {
12211     wxPy_BEGIN_ALLOW_THREADS;
12212         _result = new wxColour (wxGrid_GetSelectionForeground(_arg0));
12213
12214     wxPy_END_ALLOW_THREADS;
12215     if (PyErr_Occurred()) return NULL;
12216 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12217     _resultobj = Py_BuildValue("s",_ptemp);
12218     return _resultobj;
12219 }
12220
12221 #define wxGrid_SetSelectionBackground(_swigobj,_swigarg0)  (_swigobj->SetSelectionBackground(_swigarg0))
12222 static PyObject *_wrap_wxGrid_SetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12223     PyObject * _resultobj;
12224     wxGrid * _arg0;
12225     wxColour * _arg1;
12226     PyObject * _argo0 = 0;
12227     wxColour  temp;
12228     PyObject * _obj1 = 0;
12229     char *_kwnames[] = { "self","c", NULL };
12230
12231     self = self;
12232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionBackground",_kwnames,&_argo0,&_obj1))
12233         return NULL;
12234     if (_argo0) {
12235         if (_argo0 == Py_None) { _arg0 = NULL; }
12236         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12237             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionBackground. Expected _wxGrid_p.");
12238         return NULL;
12239         }
12240     }
12241 {
12242     _arg1 = &temp;
12243     if (! wxColour_helper(_obj1, &_arg1))
12244         return NULL;
12245 }
12246 {
12247     wxPy_BEGIN_ALLOW_THREADS;
12248         wxGrid_SetSelectionBackground(_arg0,*_arg1);
12249
12250     wxPy_END_ALLOW_THREADS;
12251     if (PyErr_Occurred()) return NULL;
12252 }    Py_INCREF(Py_None);
12253     _resultobj = Py_None;
12254     return _resultobj;
12255 }
12256
12257 #define wxGrid_SetSelectionForeground(_swigobj,_swigarg0)  (_swigobj->SetSelectionForeground(_swigarg0))
12258 static PyObject *_wrap_wxGrid_SetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12259     PyObject * _resultobj;
12260     wxGrid * _arg0;
12261     wxColour * _arg1;
12262     PyObject * _argo0 = 0;
12263     wxColour  temp;
12264     PyObject * _obj1 = 0;
12265     char *_kwnames[] = { "self","c", NULL };
12266
12267     self = self;
12268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionForeground",_kwnames,&_argo0,&_obj1))
12269         return NULL;
12270     if (_argo0) {
12271         if (_argo0 == Py_None) { _arg0 = NULL; }
12272         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12273             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionForeground. Expected _wxGrid_p.");
12274         return NULL;
12275         }
12276     }
12277 {
12278     _arg1 = &temp;
12279     if (! wxColour_helper(_obj1, &_arg1))
12280         return NULL;
12281 }
12282 {
12283     wxPy_BEGIN_ALLOW_THREADS;
12284         wxGrid_SetSelectionForeground(_arg0,*_arg1);
12285
12286     wxPy_END_ALLOW_THREADS;
12287     if (PyErr_Occurred()) return NULL;
12288 }    Py_INCREF(Py_None);
12289     _resultobj = Py_None;
12290     return _resultobj;
12291 }
12292
12293 #define wxGrid_RegisterDataType(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->RegisterDataType(_swigarg0,_swigarg1,_swigarg2))
12294 static PyObject *_wrap_wxGrid_RegisterDataType(PyObject *self, PyObject *args, PyObject *kwargs) {
12295     PyObject * _resultobj;
12296     wxGrid * _arg0;
12297     wxString * _arg1;
12298     wxGridCellRenderer * _arg2;
12299     wxGridCellEditor * _arg3;
12300     PyObject * _argo0 = 0;
12301     PyObject * _obj1 = 0;
12302     PyObject * _argo2 = 0;
12303     PyObject * _argo3 = 0;
12304     char *_kwnames[] = { "self","typeName","renderer","editor", NULL };
12305
12306     self = self;
12307     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO:wxGrid_RegisterDataType",_kwnames,&_argo0,&_obj1,&_argo2,&_argo3))
12308         return NULL;
12309     if (_argo0) {
12310         if (_argo0 == Py_None) { _arg0 = NULL; }
12311         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12312             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_RegisterDataType. Expected _wxGrid_p.");
12313         return NULL;
12314         }
12315     }
12316 {
12317 #if PYTHON_API_VERSION >= 1009
12318     char* tmpPtr; int tmpSize;
12319     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12320         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12321         return NULL;
12322     }
12323     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12324         return NULL;
12325     _arg1 = new wxString(tmpPtr, tmpSize);
12326 #else
12327     if (!PyString_Check(_obj1)) {
12328         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12329         return NULL;
12330     }
12331     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12332 #endif
12333 }
12334     if (_argo2) {
12335         if (_argo2 == Py_None) { _arg2 = NULL; }
12336         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellRenderer_p")) {
12337             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_RegisterDataType. Expected _wxGridCellRenderer_p.");
12338         return NULL;
12339         }
12340     }
12341     if (_argo3) {
12342         if (_argo3 == Py_None) { _arg3 = NULL; }
12343         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
12344             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_RegisterDataType. Expected _wxGridCellEditor_p.");
12345         return NULL;
12346         }
12347     }
12348 {
12349     wxPy_BEGIN_ALLOW_THREADS;
12350         wxGrid_RegisterDataType(_arg0,*_arg1,_arg2,_arg3);
12351
12352     wxPy_END_ALLOW_THREADS;
12353     if (PyErr_Occurred()) return NULL;
12354 }    Py_INCREF(Py_None);
12355     _resultobj = Py_None;
12356 {
12357     if (_obj1)
12358         delete _arg1;
12359 }
12360     return _resultobj;
12361 }
12362
12363 #define wxGrid_GetDefaultEditorForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultEditorForCell(_swigarg0,_swigarg1))
12364 static PyObject *_wrap_wxGrid_GetDefaultEditorForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12365     PyObject * _resultobj;
12366     wxGridCellEditor * _result;
12367     wxGrid * _arg0;
12368     int  _arg1;
12369     int  _arg2;
12370     PyObject * _argo0 = 0;
12371     char *_kwnames[] = { "self","row","col", NULL };
12372     char _ptemp[128];
12373
12374     self = self;
12375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultEditorForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12376         return NULL;
12377     if (_argo0) {
12378         if (_argo0 == Py_None) { _arg0 = NULL; }
12379         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12380             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForCell. Expected _wxGrid_p.");
12381         return NULL;
12382         }
12383     }
12384 {
12385     wxPy_BEGIN_ALLOW_THREADS;
12386         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForCell(_arg0,_arg1,_arg2);
12387
12388     wxPy_END_ALLOW_THREADS;
12389     if (PyErr_Occurred()) return NULL;
12390 }    if (_result) {
12391         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12392         _resultobj = Py_BuildValue("s",_ptemp);
12393     } else {
12394         Py_INCREF(Py_None);
12395         _resultobj = Py_None;
12396     }
12397     return _resultobj;
12398 }
12399
12400 #define wxGrid_GetDefaultRendererForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultRendererForCell(_swigarg0,_swigarg1))
12401 static PyObject *_wrap_wxGrid_GetDefaultRendererForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12402     PyObject * _resultobj;
12403     wxGridCellRenderer * _result;
12404     wxGrid * _arg0;
12405     int  _arg1;
12406     int  _arg2;
12407     PyObject * _argo0 = 0;
12408     char *_kwnames[] = { "self","row","col", NULL };
12409     char _ptemp[128];
12410
12411     self = self;
12412     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultRendererForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12413         return NULL;
12414     if (_argo0) {
12415         if (_argo0 == Py_None) { _arg0 = NULL; }
12416         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12417             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForCell. Expected _wxGrid_p.");
12418         return NULL;
12419         }
12420     }
12421 {
12422     wxPy_BEGIN_ALLOW_THREADS;
12423         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForCell(_arg0,_arg1,_arg2);
12424
12425     wxPy_END_ALLOW_THREADS;
12426     if (PyErr_Occurred()) return NULL;
12427 }    if (_result) {
12428         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12429         _resultobj = Py_BuildValue("s",_ptemp);
12430     } else {
12431         Py_INCREF(Py_None);
12432         _resultobj = Py_None;
12433     }
12434     return _resultobj;
12435 }
12436
12437 #define wxGrid_GetDefaultEditorForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultEditorForType(_swigarg0))
12438 static PyObject *_wrap_wxGrid_GetDefaultEditorForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12439     PyObject * _resultobj;
12440     wxGridCellEditor * _result;
12441     wxGrid * _arg0;
12442     wxString * _arg1;
12443     PyObject * _argo0 = 0;
12444     PyObject * _obj1 = 0;
12445     char *_kwnames[] = { "self","typeName", NULL };
12446     char _ptemp[128];
12447
12448     self = self;
12449     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultEditorForType",_kwnames,&_argo0,&_obj1))
12450         return NULL;
12451     if (_argo0) {
12452         if (_argo0 == Py_None) { _arg0 = NULL; }
12453         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12454             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForType. Expected _wxGrid_p.");
12455         return NULL;
12456         }
12457     }
12458 {
12459 #if PYTHON_API_VERSION >= 1009
12460     char* tmpPtr; int tmpSize;
12461     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12462         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12463         return NULL;
12464     }
12465     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12466         return NULL;
12467     _arg1 = new wxString(tmpPtr, tmpSize);
12468 #else
12469     if (!PyString_Check(_obj1)) {
12470         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12471         return NULL;
12472     }
12473     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12474 #endif
12475 }
12476 {
12477     wxPy_BEGIN_ALLOW_THREADS;
12478         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForType(_arg0,*_arg1);
12479
12480     wxPy_END_ALLOW_THREADS;
12481     if (PyErr_Occurred()) return NULL;
12482 }    if (_result) {
12483         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12484         _resultobj = Py_BuildValue("s",_ptemp);
12485     } else {
12486         Py_INCREF(Py_None);
12487         _resultobj = Py_None;
12488     }
12489 {
12490     if (_obj1)
12491         delete _arg1;
12492 }
12493     return _resultobj;
12494 }
12495
12496 #define wxGrid_GetDefaultRendererForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultRendererForType(_swigarg0))
12497 static PyObject *_wrap_wxGrid_GetDefaultRendererForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12498     PyObject * _resultobj;
12499     wxGridCellRenderer * _result;
12500     wxGrid * _arg0;
12501     wxString * _arg1;
12502     PyObject * _argo0 = 0;
12503     PyObject * _obj1 = 0;
12504     char *_kwnames[] = { "self","typeName", NULL };
12505     char _ptemp[128];
12506
12507     self = self;
12508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultRendererForType",_kwnames,&_argo0,&_obj1))
12509         return NULL;
12510     if (_argo0) {
12511         if (_argo0 == Py_None) { _arg0 = NULL; }
12512         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12513             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForType. Expected _wxGrid_p.");
12514         return NULL;
12515         }
12516     }
12517 {
12518 #if PYTHON_API_VERSION >= 1009
12519     char* tmpPtr; int tmpSize;
12520     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12521         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12522         return NULL;
12523     }
12524     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12525         return NULL;
12526     _arg1 = new wxString(tmpPtr, tmpSize);
12527 #else
12528     if (!PyString_Check(_obj1)) {
12529         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12530         return NULL;
12531     }
12532     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12533 #endif
12534 }
12535 {
12536     wxPy_BEGIN_ALLOW_THREADS;
12537         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForType(_arg0,*_arg1);
12538
12539     wxPy_END_ALLOW_THREADS;
12540     if (PyErr_Occurred()) return NULL;
12541 }    if (_result) {
12542         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12543         _resultobj = Py_BuildValue("s",_ptemp);
12544     } else {
12545         Py_INCREF(Py_None);
12546         _resultobj = Py_None;
12547     }
12548 {
12549     if (_obj1)
12550         delete _arg1;
12551 }
12552     return _resultobj;
12553 }
12554
12555 #define wxGrid_SetMargins(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetMargins(_swigarg0,_swigarg1))
12556 static PyObject *_wrap_wxGrid_SetMargins(PyObject *self, PyObject *args, PyObject *kwargs) {
12557     PyObject * _resultobj;
12558     wxGrid * _arg0;
12559     int  _arg1;
12560     int  _arg2;
12561     PyObject * _argo0 = 0;
12562     char *_kwnames[] = { "self","extraWidth","extraHeight", NULL };
12563
12564     self = self;
12565     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetMargins",_kwnames,&_argo0,&_arg1,&_arg2))
12566         return NULL;
12567     if (_argo0) {
12568         if (_argo0 == Py_None) { _arg0 = NULL; }
12569         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12570             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetMargins. Expected _wxGrid_p.");
12571         return NULL;
12572         }
12573     }
12574 {
12575     wxPy_BEGIN_ALLOW_THREADS;
12576         wxGrid_SetMargins(_arg0,_arg1,_arg2);
12577
12578     wxPy_END_ALLOW_THREADS;
12579     if (PyErr_Occurred()) return NULL;
12580 }    Py_INCREF(Py_None);
12581     _resultobj = Py_None;
12582     return _resultobj;
12583 }
12584
12585 #define wxGrid_GetGridWindow(_swigobj)  (_swigobj->GetGridWindow())
12586 static PyObject *_wrap_wxGrid_GetGridWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12587     PyObject * _resultobj;
12588     wxWindow * _result;
12589     wxGrid * _arg0;
12590     PyObject * _argo0 = 0;
12591     char *_kwnames[] = { "self", NULL };
12592
12593     self = self;
12594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridWindow",_kwnames,&_argo0))
12595         return NULL;
12596     if (_argo0) {
12597         if (_argo0 == Py_None) { _arg0 = NULL; }
12598         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12599             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridWindow. Expected _wxGrid_p.");
12600         return NULL;
12601         }
12602     }
12603 {
12604     wxPy_BEGIN_ALLOW_THREADS;
12605         _result = (wxWindow *)wxGrid_GetGridWindow(_arg0);
12606
12607     wxPy_END_ALLOW_THREADS;
12608     if (PyErr_Occurred()) return NULL;
12609 }{ _resultobj = wxPyMake_wxObject(_result); }
12610     return _resultobj;
12611 }
12612
12613 #define wxGrid_GetGridRowLabelWindow(_swigobj)  (_swigobj->GetGridRowLabelWindow())
12614 static PyObject *_wrap_wxGrid_GetGridRowLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12615     PyObject * _resultobj;
12616     wxWindow * _result;
12617     wxGrid * _arg0;
12618     PyObject * _argo0 = 0;
12619     char *_kwnames[] = { "self", NULL };
12620
12621     self = self;
12622     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridRowLabelWindow",_kwnames,&_argo0))
12623         return NULL;
12624     if (_argo0) {
12625         if (_argo0 == Py_None) { _arg0 = NULL; }
12626         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12627             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridRowLabelWindow. Expected _wxGrid_p.");
12628         return NULL;
12629         }
12630     }
12631 {
12632     wxPy_BEGIN_ALLOW_THREADS;
12633         _result = (wxWindow *)wxGrid_GetGridRowLabelWindow(_arg0);
12634
12635     wxPy_END_ALLOW_THREADS;
12636     if (PyErr_Occurred()) return NULL;
12637 }{ _resultobj = wxPyMake_wxObject(_result); }
12638     return _resultobj;
12639 }
12640
12641 #define wxGrid_GetGridColLabelWindow(_swigobj)  (_swigobj->GetGridColLabelWindow())
12642 static PyObject *_wrap_wxGrid_GetGridColLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12643     PyObject * _resultobj;
12644     wxWindow * _result;
12645     wxGrid * _arg0;
12646     PyObject * _argo0 = 0;
12647     char *_kwnames[] = { "self", NULL };
12648
12649     self = self;
12650     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridColLabelWindow",_kwnames,&_argo0))
12651         return NULL;
12652     if (_argo0) {
12653         if (_argo0 == Py_None) { _arg0 = NULL; }
12654         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12655             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridColLabelWindow. Expected _wxGrid_p.");
12656         return NULL;
12657         }
12658     }
12659 {
12660     wxPy_BEGIN_ALLOW_THREADS;
12661         _result = (wxWindow *)wxGrid_GetGridColLabelWindow(_arg0);
12662
12663     wxPy_END_ALLOW_THREADS;
12664     if (PyErr_Occurred()) return NULL;
12665 }{ _resultobj = wxPyMake_wxObject(_result); }
12666     return _resultobj;
12667 }
12668
12669 #define wxGrid_GetGridCornerLabelWindow(_swigobj)  (_swigobj->GetGridCornerLabelWindow())
12670 static PyObject *_wrap_wxGrid_GetGridCornerLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12671     PyObject * _resultobj;
12672     wxWindow * _result;
12673     wxGrid * _arg0;
12674     PyObject * _argo0 = 0;
12675     char *_kwnames[] = { "self", NULL };
12676
12677     self = self;
12678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCornerLabelWindow",_kwnames,&_argo0))
12679         return NULL;
12680     if (_argo0) {
12681         if (_argo0 == Py_None) { _arg0 = NULL; }
12682         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12683             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCornerLabelWindow. Expected _wxGrid_p.");
12684         return NULL;
12685         }
12686     }
12687 {
12688     wxPy_BEGIN_ALLOW_THREADS;
12689         _result = (wxWindow *)wxGrid_GetGridCornerLabelWindow(_arg0);
12690
12691     wxPy_END_ALLOW_THREADS;
12692     if (PyErr_Occurred()) return NULL;
12693 }{ _resultobj = wxPyMake_wxObject(_result); }
12694     return _resultobj;
12695 }
12696
12697 static void *SwigwxGridEventTowxNotifyEvent(void *ptr) {
12698     wxGridEvent *src;
12699     wxNotifyEvent *dest;
12700     src = (wxGridEvent *) ptr;
12701     dest = (wxNotifyEvent *) src;
12702     return (void *) dest;
12703 }
12704
12705 static void *SwigwxGridEventTowxCommandEvent(void *ptr) {
12706     wxGridEvent *src;
12707     wxCommandEvent *dest;
12708     src = (wxGridEvent *) ptr;
12709     dest = (wxCommandEvent *) src;
12710     return (void *) dest;
12711 }
12712
12713 static void *SwigwxGridEventTowxEvent(void *ptr) {
12714     wxGridEvent *src;
12715     wxEvent *dest;
12716     src = (wxGridEvent *) ptr;
12717     dest = (wxEvent *) src;
12718     return (void *) dest;
12719 }
12720
12721 static void *SwigwxGridEventTowxObject(void *ptr) {
12722     wxGridEvent *src;
12723     wxObject *dest;
12724     src = (wxGridEvent *) ptr;
12725     dest = (wxObject *) src;
12726     return (void *) dest;
12727 }
12728
12729 #define new_wxGridEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9,_swigarg10,_swigarg11) (new wxGridEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9,_swigarg10,_swigarg11))
12730 static PyObject *_wrap_new_wxGridEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
12731     PyObject * _resultobj;
12732     wxGridEvent * _result;
12733     int  _arg0;
12734     wxEventType  _arg1;
12735     wxGrid * _arg2;
12736     int  _arg3 = (int ) -1;
12737     int  _arg4 = (int ) -1;
12738     int  _arg5 = (int ) -1;
12739     int  _arg6 = (int ) -1;
12740     bool  _arg7 = (bool ) TRUE;
12741     bool  _arg8 = (bool ) FALSE;
12742     bool  _arg9 = (bool ) FALSE;
12743     bool  _arg10 = (bool ) FALSE;
12744     bool  _arg11 = (bool ) FALSE;
12745     PyObject * _argo2 = 0;
12746     int tempbool7 = (int) TRUE;
12747     int tempbool8 = (int) FALSE;
12748     int tempbool9 = (int) FALSE;
12749     int tempbool10 = (int) FALSE;
12750     int tempbool11 = (int) FALSE;
12751     char *_kwnames[] = { "id","type","obj","row","col","x","y","sel","control","shift","alt","meta", NULL };
12752     char _ptemp[128];
12753
12754     self = self;
12755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiiiii:new_wxGridEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&_arg6,&tempbool7,&tempbool8,&tempbool9,&tempbool10,&tempbool11))
12756         return NULL;
12757     if (_argo2) {
12758         if (_argo2 == Py_None) { _arg2 = NULL; }
12759         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
12760             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEvent. Expected _wxGrid_p.");
12761         return NULL;
12762         }
12763     }
12764     _arg7 = (bool ) tempbool7;
12765     _arg8 = (bool ) tempbool8;
12766     _arg9 = (bool ) tempbool9;
12767     _arg10 = (bool ) tempbool10;
12768     _arg11 = (bool ) tempbool11;
12769 {
12770     wxPy_BEGIN_ALLOW_THREADS;
12771         _result = (wxGridEvent *)new_wxGridEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9,_arg10,_arg11);
12772
12773     wxPy_END_ALLOW_THREADS;
12774     if (PyErr_Occurred()) return NULL;
12775 }    if (_result) {
12776         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEvent_p");
12777         _resultobj = Py_BuildValue("s",_ptemp);
12778     } else {
12779         Py_INCREF(Py_None);
12780         _resultobj = Py_None;
12781     }
12782     return _resultobj;
12783 }
12784
12785 #define wxGridEvent_GetRow(_swigobj)  (_swigobj->GetRow())
12786 static PyObject *_wrap_wxGridEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
12787     PyObject * _resultobj;
12788     int  _result;
12789     wxGridEvent * _arg0;
12790     PyObject * _argo0 = 0;
12791     char *_kwnames[] = { "self", NULL };
12792
12793     self = self;
12794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetRow",_kwnames,&_argo0))
12795         return NULL;
12796     if (_argo0) {
12797         if (_argo0 == Py_None) { _arg0 = NULL; }
12798         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12799             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetRow. Expected _wxGridEvent_p.");
12800         return NULL;
12801         }
12802     }
12803 {
12804     wxPy_BEGIN_ALLOW_THREADS;
12805         _result = (int )wxGridEvent_GetRow(_arg0);
12806
12807     wxPy_END_ALLOW_THREADS;
12808     if (PyErr_Occurred()) return NULL;
12809 }    _resultobj = Py_BuildValue("i",_result);
12810     return _resultobj;
12811 }
12812
12813 #define wxGridEvent_GetCol(_swigobj)  (_swigobj->GetCol())
12814 static PyObject *_wrap_wxGridEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
12815     PyObject * _resultobj;
12816     int  _result;
12817     wxGridEvent * _arg0;
12818     PyObject * _argo0 = 0;
12819     char *_kwnames[] = { "self", NULL };
12820
12821     self = self;
12822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetCol",_kwnames,&_argo0))
12823         return NULL;
12824     if (_argo0) {
12825         if (_argo0 == Py_None) { _arg0 = NULL; }
12826         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12827             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetCol. Expected _wxGridEvent_p.");
12828         return NULL;
12829         }
12830     }
12831 {
12832     wxPy_BEGIN_ALLOW_THREADS;
12833         _result = (int )wxGridEvent_GetCol(_arg0);
12834
12835     wxPy_END_ALLOW_THREADS;
12836     if (PyErr_Occurred()) return NULL;
12837 }    _resultobj = Py_BuildValue("i",_result);
12838     return _resultobj;
12839 }
12840
12841 #define wxGridEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
12842 static PyObject *_wrap_wxGridEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
12843     PyObject * _resultobj;
12844     wxPoint * _result;
12845     wxGridEvent * _arg0;
12846     PyObject * _argo0 = 0;
12847     char *_kwnames[] = { "self", NULL };
12848     char _ptemp[128];
12849
12850     self = self;
12851     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetPosition",_kwnames,&_argo0))
12852         return NULL;
12853     if (_argo0) {
12854         if (_argo0 == Py_None) { _arg0 = NULL; }
12855         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12856             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetPosition. Expected _wxGridEvent_p.");
12857         return NULL;
12858         }
12859     }
12860 {
12861     wxPy_BEGIN_ALLOW_THREADS;
12862         _result = new wxPoint (wxGridEvent_GetPosition(_arg0));
12863
12864     wxPy_END_ALLOW_THREADS;
12865     if (PyErr_Occurred()) return NULL;
12866 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
12867     _resultobj = Py_BuildValue("s",_ptemp);
12868     return _resultobj;
12869 }
12870
12871 #define wxGridEvent_Selecting(_swigobj)  (_swigobj->Selecting())
12872 static PyObject *_wrap_wxGridEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
12873     PyObject * _resultobj;
12874     bool  _result;
12875     wxGridEvent * _arg0;
12876     PyObject * _argo0 = 0;
12877     char *_kwnames[] = { "self", NULL };
12878
12879     self = self;
12880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_Selecting",_kwnames,&_argo0))
12881         return NULL;
12882     if (_argo0) {
12883         if (_argo0 == Py_None) { _arg0 = NULL; }
12884         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12885             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_Selecting. Expected _wxGridEvent_p.");
12886         return NULL;
12887         }
12888     }
12889 {
12890     wxPy_BEGIN_ALLOW_THREADS;
12891         _result = (bool )wxGridEvent_Selecting(_arg0);
12892
12893     wxPy_END_ALLOW_THREADS;
12894     if (PyErr_Occurred()) return NULL;
12895 }    _resultobj = Py_BuildValue("i",_result);
12896     return _resultobj;
12897 }
12898
12899 #define wxGridEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
12900 static PyObject *_wrap_wxGridEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12901     PyObject * _resultobj;
12902     bool  _result;
12903     wxGridEvent * _arg0;
12904     PyObject * _argo0 = 0;
12905     char *_kwnames[] = { "self", NULL };
12906
12907     self = self;
12908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ControlDown",_kwnames,&_argo0))
12909         return NULL;
12910     if (_argo0) {
12911         if (_argo0 == Py_None) { _arg0 = NULL; }
12912         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12913             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ControlDown. Expected _wxGridEvent_p.");
12914         return NULL;
12915         }
12916     }
12917 {
12918     wxPy_BEGIN_ALLOW_THREADS;
12919         _result = (bool )wxGridEvent_ControlDown(_arg0);
12920
12921     wxPy_END_ALLOW_THREADS;
12922     if (PyErr_Occurred()) return NULL;
12923 }    _resultobj = Py_BuildValue("i",_result);
12924     return _resultobj;
12925 }
12926
12927 #define wxGridEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
12928 static PyObject *_wrap_wxGridEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12929     PyObject * _resultobj;
12930     bool  _result;
12931     wxGridEvent * _arg0;
12932     PyObject * _argo0 = 0;
12933     char *_kwnames[] = { "self", NULL };
12934
12935     self = self;
12936     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_MetaDown",_kwnames,&_argo0))
12937         return NULL;
12938     if (_argo0) {
12939         if (_argo0 == Py_None) { _arg0 = NULL; }
12940         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12941             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_MetaDown. Expected _wxGridEvent_p.");
12942         return NULL;
12943         }
12944     }
12945 {
12946     wxPy_BEGIN_ALLOW_THREADS;
12947         _result = (bool )wxGridEvent_MetaDown(_arg0);
12948
12949     wxPy_END_ALLOW_THREADS;
12950     if (PyErr_Occurred()) return NULL;
12951 }    _resultobj = Py_BuildValue("i",_result);
12952     return _resultobj;
12953 }
12954
12955 #define wxGridEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
12956 static PyObject *_wrap_wxGridEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12957     PyObject * _resultobj;
12958     bool  _result;
12959     wxGridEvent * _arg0;
12960     PyObject * _argo0 = 0;
12961     char *_kwnames[] = { "self", NULL };
12962
12963     self = self;
12964     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ShiftDown",_kwnames,&_argo0))
12965         return NULL;
12966     if (_argo0) {
12967         if (_argo0 == Py_None) { _arg0 = NULL; }
12968         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12969             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ShiftDown. Expected _wxGridEvent_p.");
12970         return NULL;
12971         }
12972     }
12973 {
12974     wxPy_BEGIN_ALLOW_THREADS;
12975         _result = (bool )wxGridEvent_ShiftDown(_arg0);
12976
12977     wxPy_END_ALLOW_THREADS;
12978     if (PyErr_Occurred()) return NULL;
12979 }    _resultobj = Py_BuildValue("i",_result);
12980     return _resultobj;
12981 }
12982
12983 #define wxGridEvent_AltDown(_swigobj)  (_swigobj->AltDown())
12984 static PyObject *_wrap_wxGridEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12985     PyObject * _resultobj;
12986     bool  _result;
12987     wxGridEvent * _arg0;
12988     PyObject * _argo0 = 0;
12989     char *_kwnames[] = { "self", NULL };
12990
12991     self = self;
12992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_AltDown",_kwnames,&_argo0))
12993         return NULL;
12994     if (_argo0) {
12995         if (_argo0 == Py_None) { _arg0 = NULL; }
12996         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12997             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_AltDown. Expected _wxGridEvent_p.");
12998         return NULL;
12999         }
13000     }
13001 {
13002     wxPy_BEGIN_ALLOW_THREADS;
13003         _result = (bool )wxGridEvent_AltDown(_arg0);
13004
13005     wxPy_END_ALLOW_THREADS;
13006     if (PyErr_Occurred()) return NULL;
13007 }    _resultobj = Py_BuildValue("i",_result);
13008     return _resultobj;
13009 }
13010
13011 static void *SwigwxGridSizeEventTowxNotifyEvent(void *ptr) {
13012     wxGridSizeEvent *src;
13013     wxNotifyEvent *dest;
13014     src = (wxGridSizeEvent *) ptr;
13015     dest = (wxNotifyEvent *) src;
13016     return (void *) dest;
13017 }
13018
13019 static void *SwigwxGridSizeEventTowxCommandEvent(void *ptr) {
13020     wxGridSizeEvent *src;
13021     wxCommandEvent *dest;
13022     src = (wxGridSizeEvent *) ptr;
13023     dest = (wxCommandEvent *) src;
13024     return (void *) dest;
13025 }
13026
13027 static void *SwigwxGridSizeEventTowxEvent(void *ptr) {
13028     wxGridSizeEvent *src;
13029     wxEvent *dest;
13030     src = (wxGridSizeEvent *) ptr;
13031     dest = (wxEvent *) src;
13032     return (void *) dest;
13033 }
13034
13035 static void *SwigwxGridSizeEventTowxObject(void *ptr) {
13036     wxGridSizeEvent *src;
13037     wxObject *dest;
13038     src = (wxGridSizeEvent *) ptr;
13039     dest = (wxObject *) src;
13040     return (void *) dest;
13041 }
13042
13043 #define new_wxGridSizeEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9) (new wxGridSizeEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9))
13044 static PyObject *_wrap_new_wxGridSizeEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13045     PyObject * _resultobj;
13046     wxGridSizeEvent * _result;
13047     int  _arg0;
13048     wxEventType  _arg1;
13049     wxGrid * _arg2;
13050     int  _arg3 = (int ) -1;
13051     int  _arg4 = (int ) -1;
13052     int  _arg5 = (int ) -1;
13053     bool  _arg6 = (bool ) FALSE;
13054     bool  _arg7 = (bool ) FALSE;
13055     bool  _arg8 = (bool ) FALSE;
13056     bool  _arg9 = (bool ) FALSE;
13057     PyObject * _argo2 = 0;
13058     int tempbool6 = (int) FALSE;
13059     int tempbool7 = (int) FALSE;
13060     int tempbool8 = (int) FALSE;
13061     int tempbool9 = (int) FALSE;
13062     char *_kwnames[] = { "id","type","obj","rowOrCol","x","y","control","shift","alt","meta", NULL };
13063     char _ptemp[128];
13064
13065     self = self;
13066     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiii:new_wxGridSizeEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13067         return NULL;
13068     if (_argo2) {
13069         if (_argo2 == Py_None) { _arg2 = NULL; }
13070         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13071             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridSizeEvent. Expected _wxGrid_p.");
13072         return NULL;
13073         }
13074     }
13075     _arg6 = (bool ) tempbool6;
13076     _arg7 = (bool ) tempbool7;
13077     _arg8 = (bool ) tempbool8;
13078     _arg9 = (bool ) tempbool9;
13079 {
13080     wxPy_BEGIN_ALLOW_THREADS;
13081         _result = (wxGridSizeEvent *)new_wxGridSizeEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13082
13083     wxPy_END_ALLOW_THREADS;
13084     if (PyErr_Occurred()) return NULL;
13085 }    if (_result) {
13086         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridSizeEvent_p");
13087         _resultobj = Py_BuildValue("s",_ptemp);
13088     } else {
13089         Py_INCREF(Py_None);
13090         _resultobj = Py_None;
13091     }
13092     return _resultobj;
13093 }
13094
13095 #define wxGridSizeEvent_GetRowOrCol(_swigobj)  (_swigobj->GetRowOrCol())
13096 static PyObject *_wrap_wxGridSizeEvent_GetRowOrCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13097     PyObject * _resultobj;
13098     int  _result;
13099     wxGridSizeEvent * _arg0;
13100     PyObject * _argo0 = 0;
13101     char *_kwnames[] = { "self", NULL };
13102
13103     self = self;
13104     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetRowOrCol",_kwnames,&_argo0))
13105         return NULL;
13106     if (_argo0) {
13107         if (_argo0 == Py_None) { _arg0 = NULL; }
13108         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13109             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetRowOrCol. Expected _wxGridSizeEvent_p.");
13110         return NULL;
13111         }
13112     }
13113 {
13114     wxPy_BEGIN_ALLOW_THREADS;
13115         _result = (int )wxGridSizeEvent_GetRowOrCol(_arg0);
13116
13117     wxPy_END_ALLOW_THREADS;
13118     if (PyErr_Occurred()) return NULL;
13119 }    _resultobj = Py_BuildValue("i",_result);
13120     return _resultobj;
13121 }
13122
13123 #define wxGridSizeEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
13124 static PyObject *_wrap_wxGridSizeEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
13125     PyObject * _resultobj;
13126     wxPoint * _result;
13127     wxGridSizeEvent * _arg0;
13128     PyObject * _argo0 = 0;
13129     char *_kwnames[] = { "self", NULL };
13130     char _ptemp[128];
13131
13132     self = self;
13133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetPosition",_kwnames,&_argo0))
13134         return NULL;
13135     if (_argo0) {
13136         if (_argo0 == Py_None) { _arg0 = NULL; }
13137         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13138             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetPosition. Expected _wxGridSizeEvent_p.");
13139         return NULL;
13140         }
13141     }
13142 {
13143     wxPy_BEGIN_ALLOW_THREADS;
13144         _result = new wxPoint (wxGridSizeEvent_GetPosition(_arg0));
13145
13146     wxPy_END_ALLOW_THREADS;
13147     if (PyErr_Occurred()) return NULL;
13148 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
13149     _resultobj = Py_BuildValue("s",_ptemp);
13150     return _resultobj;
13151 }
13152
13153 #define wxGridSizeEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13154 static PyObject *_wrap_wxGridSizeEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13155     PyObject * _resultobj;
13156     bool  _result;
13157     wxGridSizeEvent * _arg0;
13158     PyObject * _argo0 = 0;
13159     char *_kwnames[] = { "self", NULL };
13160
13161     self = self;
13162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ControlDown",_kwnames,&_argo0))
13163         return NULL;
13164     if (_argo0) {
13165         if (_argo0 == Py_None) { _arg0 = NULL; }
13166         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13167             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ControlDown. Expected _wxGridSizeEvent_p.");
13168         return NULL;
13169         }
13170     }
13171 {
13172     wxPy_BEGIN_ALLOW_THREADS;
13173         _result = (bool )wxGridSizeEvent_ControlDown(_arg0);
13174
13175     wxPy_END_ALLOW_THREADS;
13176     if (PyErr_Occurred()) return NULL;
13177 }    _resultobj = Py_BuildValue("i",_result);
13178     return _resultobj;
13179 }
13180
13181 #define wxGridSizeEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13182 static PyObject *_wrap_wxGridSizeEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13183     PyObject * _resultobj;
13184     bool  _result;
13185     wxGridSizeEvent * _arg0;
13186     PyObject * _argo0 = 0;
13187     char *_kwnames[] = { "self", NULL };
13188
13189     self = self;
13190     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_MetaDown",_kwnames,&_argo0))
13191         return NULL;
13192     if (_argo0) {
13193         if (_argo0 == Py_None) { _arg0 = NULL; }
13194         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13195             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_MetaDown. Expected _wxGridSizeEvent_p.");
13196         return NULL;
13197         }
13198     }
13199 {
13200     wxPy_BEGIN_ALLOW_THREADS;
13201         _result = (bool )wxGridSizeEvent_MetaDown(_arg0);
13202
13203     wxPy_END_ALLOW_THREADS;
13204     if (PyErr_Occurred()) return NULL;
13205 }    _resultobj = Py_BuildValue("i",_result);
13206     return _resultobj;
13207 }
13208
13209 #define wxGridSizeEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13210 static PyObject *_wrap_wxGridSizeEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13211     PyObject * _resultobj;
13212     bool  _result;
13213     wxGridSizeEvent * _arg0;
13214     PyObject * _argo0 = 0;
13215     char *_kwnames[] = { "self", NULL };
13216
13217     self = self;
13218     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ShiftDown",_kwnames,&_argo0))
13219         return NULL;
13220     if (_argo0) {
13221         if (_argo0 == Py_None) { _arg0 = NULL; }
13222         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13223             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ShiftDown. Expected _wxGridSizeEvent_p.");
13224         return NULL;
13225         }
13226     }
13227 {
13228     wxPy_BEGIN_ALLOW_THREADS;
13229         _result = (bool )wxGridSizeEvent_ShiftDown(_arg0);
13230
13231     wxPy_END_ALLOW_THREADS;
13232     if (PyErr_Occurred()) return NULL;
13233 }    _resultobj = Py_BuildValue("i",_result);
13234     return _resultobj;
13235 }
13236
13237 #define wxGridSizeEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13238 static PyObject *_wrap_wxGridSizeEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13239     PyObject * _resultobj;
13240     bool  _result;
13241     wxGridSizeEvent * _arg0;
13242     PyObject * _argo0 = 0;
13243     char *_kwnames[] = { "self", NULL };
13244
13245     self = self;
13246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_AltDown",_kwnames,&_argo0))
13247         return NULL;
13248     if (_argo0) {
13249         if (_argo0 == Py_None) { _arg0 = NULL; }
13250         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13251             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_AltDown. Expected _wxGridSizeEvent_p.");
13252         return NULL;
13253         }
13254     }
13255 {
13256     wxPy_BEGIN_ALLOW_THREADS;
13257         _result = (bool )wxGridSizeEvent_AltDown(_arg0);
13258
13259     wxPy_END_ALLOW_THREADS;
13260     if (PyErr_Occurred()) return NULL;
13261 }    _resultobj = Py_BuildValue("i",_result);
13262     return _resultobj;
13263 }
13264
13265 static void *SwigwxGridRangeSelectEventTowxNotifyEvent(void *ptr) {
13266     wxGridRangeSelectEvent *src;
13267     wxNotifyEvent *dest;
13268     src = (wxGridRangeSelectEvent *) ptr;
13269     dest = (wxNotifyEvent *) src;
13270     return (void *) dest;
13271 }
13272
13273 static void *SwigwxGridRangeSelectEventTowxCommandEvent(void *ptr) {
13274     wxGridRangeSelectEvent *src;
13275     wxCommandEvent *dest;
13276     src = (wxGridRangeSelectEvent *) ptr;
13277     dest = (wxCommandEvent *) src;
13278     return (void *) dest;
13279 }
13280
13281 static void *SwigwxGridRangeSelectEventTowxEvent(void *ptr) {
13282     wxGridRangeSelectEvent *src;
13283     wxEvent *dest;
13284     src = (wxGridRangeSelectEvent *) ptr;
13285     dest = (wxEvent *) src;
13286     return (void *) dest;
13287 }
13288
13289 static void *SwigwxGridRangeSelectEventTowxObject(void *ptr) {
13290     wxGridRangeSelectEvent *src;
13291     wxObject *dest;
13292     src = (wxGridRangeSelectEvent *) ptr;
13293     dest = (wxObject *) src;
13294     return (void *) dest;
13295 }
13296
13297 #define new_wxGridRangeSelectEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9) (new wxGridRangeSelectEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7,_swigarg8,_swigarg9))
13298 static PyObject *_wrap_new_wxGridRangeSelectEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13299     PyObject * _resultobj;
13300     wxGridRangeSelectEvent * _result;
13301     int  _arg0;
13302     wxEventType  _arg1;
13303     wxGrid * _arg2;
13304     wxGridCellCoords * _arg3;
13305     wxGridCellCoords * _arg4;
13306     bool  _arg5 = (bool ) TRUE;
13307     bool  _arg6 = (bool ) FALSE;
13308     bool  _arg7 = (bool ) FALSE;
13309     bool  _arg8 = (bool ) FALSE;
13310     bool  _arg9 = (bool ) FALSE;
13311     PyObject * _argo2 = 0;
13312     wxGridCellCoords  temp;
13313     PyObject * _obj3 = 0;
13314     wxGridCellCoords  temp0;
13315     PyObject * _obj4 = 0;
13316     int tempbool5 = (int) TRUE;
13317     int tempbool6 = (int) FALSE;
13318     int tempbool7 = (int) FALSE;
13319     int tempbool8 = (int) FALSE;
13320     int tempbool9 = (int) FALSE;
13321     char *_kwnames[] = { "id","type","obj","topLeft","bottomRight","sel","control","shift","alt","meta", NULL };
13322     char _ptemp[128];
13323
13324     self = self;
13325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOOO|iiiii:new_wxGridRangeSelectEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_obj3,&_obj4,&tempbool5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13326         return NULL;
13327     if (_argo2) {
13328         if (_argo2 == Py_None) { _arg2 = NULL; }
13329         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13330             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridRangeSelectEvent. Expected _wxGrid_p.");
13331         return NULL;
13332         }
13333     }
13334 {
13335     _arg3 = &temp;
13336     if (! wxGridCellCoords_helper(_obj3, &_arg3))
13337         return NULL;
13338 }
13339 {
13340     _arg4 = &temp0;
13341     if (! wxGridCellCoords_helper(_obj4, &_arg4))
13342         return NULL;
13343 }
13344     _arg5 = (bool ) tempbool5;
13345     _arg6 = (bool ) tempbool6;
13346     _arg7 = (bool ) tempbool7;
13347     _arg8 = (bool ) tempbool8;
13348     _arg9 = (bool ) tempbool9;
13349 {
13350     wxPy_BEGIN_ALLOW_THREADS;
13351         _result = (wxGridRangeSelectEvent *)new_wxGridRangeSelectEvent(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13352
13353     wxPy_END_ALLOW_THREADS;
13354     if (PyErr_Occurred()) return NULL;
13355 }    if (_result) {
13356         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridRangeSelectEvent_p");
13357         _resultobj = Py_BuildValue("s",_ptemp);
13358     } else {
13359         Py_INCREF(Py_None);
13360         _resultobj = Py_None;
13361     }
13362     return _resultobj;
13363 }
13364
13365 #define wxGridRangeSelectEvent_GetTopLeftCoords(_swigobj)  (_swigobj->GetTopLeftCoords())
13366 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopLeftCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13367     PyObject * _resultobj;
13368     wxGridCellCoords * _result;
13369     wxGridRangeSelectEvent * _arg0;
13370     PyObject * _argo0 = 0;
13371     char *_kwnames[] = { "self", NULL };
13372     char _ptemp[128];
13373
13374     self = self;
13375     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopLeftCoords",_kwnames,&_argo0))
13376         return NULL;
13377     if (_argo0) {
13378         if (_argo0 == Py_None) { _arg0 = NULL; }
13379         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13380             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopLeftCoords. Expected _wxGridRangeSelectEvent_p.");
13381         return NULL;
13382         }
13383     }
13384 {
13385     wxPy_BEGIN_ALLOW_THREADS;
13386         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetTopLeftCoords(_arg0));
13387
13388     wxPy_END_ALLOW_THREADS;
13389     if (PyErr_Occurred()) return NULL;
13390 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13391     _resultobj = Py_BuildValue("s",_ptemp);
13392     return _resultobj;
13393 }
13394
13395 #define wxGridRangeSelectEvent_GetBottomRightCoords(_swigobj)  (_swigobj->GetBottomRightCoords())
13396 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRightCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13397     PyObject * _resultobj;
13398     wxGridCellCoords * _result;
13399     wxGridRangeSelectEvent * _arg0;
13400     PyObject * _argo0 = 0;
13401     char *_kwnames[] = { "self", NULL };
13402     char _ptemp[128];
13403
13404     self = self;
13405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRightCoords",_kwnames,&_argo0))
13406         return NULL;
13407     if (_argo0) {
13408         if (_argo0 == Py_None) { _arg0 = NULL; }
13409         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13410             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRightCoords. Expected _wxGridRangeSelectEvent_p.");
13411         return NULL;
13412         }
13413     }
13414 {
13415     wxPy_BEGIN_ALLOW_THREADS;
13416         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetBottomRightCoords(_arg0));
13417
13418     wxPy_END_ALLOW_THREADS;
13419     if (PyErr_Occurred()) return NULL;
13420 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13421     _resultobj = Py_BuildValue("s",_ptemp);
13422     return _resultobj;
13423 }
13424
13425 #define wxGridRangeSelectEvent_GetTopRow(_swigobj)  (_swigobj->GetTopRow())
13426 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13427     PyObject * _resultobj;
13428     int  _result;
13429     wxGridRangeSelectEvent * _arg0;
13430     PyObject * _argo0 = 0;
13431     char *_kwnames[] = { "self", NULL };
13432
13433     self = self;
13434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopRow",_kwnames,&_argo0))
13435         return NULL;
13436     if (_argo0) {
13437         if (_argo0 == Py_None) { _arg0 = NULL; }
13438         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13439             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopRow. Expected _wxGridRangeSelectEvent_p.");
13440         return NULL;
13441         }
13442     }
13443 {
13444     wxPy_BEGIN_ALLOW_THREADS;
13445         _result = (int )wxGridRangeSelectEvent_GetTopRow(_arg0);
13446
13447     wxPy_END_ALLOW_THREADS;
13448     if (PyErr_Occurred()) return NULL;
13449 }    _resultobj = Py_BuildValue("i",_result);
13450     return _resultobj;
13451 }
13452
13453 #define wxGridRangeSelectEvent_GetBottomRow(_swigobj)  (_swigobj->GetBottomRow())
13454 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13455     PyObject * _resultobj;
13456     int  _result;
13457     wxGridRangeSelectEvent * _arg0;
13458     PyObject * _argo0 = 0;
13459     char *_kwnames[] = { "self", NULL };
13460
13461     self = self;
13462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRow",_kwnames,&_argo0))
13463         return NULL;
13464     if (_argo0) {
13465         if (_argo0 == Py_None) { _arg0 = NULL; }
13466         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13467             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRow. Expected _wxGridRangeSelectEvent_p.");
13468         return NULL;
13469         }
13470     }
13471 {
13472     wxPy_BEGIN_ALLOW_THREADS;
13473         _result = (int )wxGridRangeSelectEvent_GetBottomRow(_arg0);
13474
13475     wxPy_END_ALLOW_THREADS;
13476     if (PyErr_Occurred()) return NULL;
13477 }    _resultobj = Py_BuildValue("i",_result);
13478     return _resultobj;
13479 }
13480
13481 #define wxGridRangeSelectEvent_GetLeftCol(_swigobj)  (_swigobj->GetLeftCol())
13482 static PyObject *_wrap_wxGridRangeSelectEvent_GetLeftCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13483     PyObject * _resultobj;
13484     int  _result;
13485     wxGridRangeSelectEvent * _arg0;
13486     PyObject * _argo0 = 0;
13487     char *_kwnames[] = { "self", NULL };
13488
13489     self = self;
13490     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetLeftCol",_kwnames,&_argo0))
13491         return NULL;
13492     if (_argo0) {
13493         if (_argo0 == Py_None) { _arg0 = NULL; }
13494         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13495             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetLeftCol. Expected _wxGridRangeSelectEvent_p.");
13496         return NULL;
13497         }
13498     }
13499 {
13500     wxPy_BEGIN_ALLOW_THREADS;
13501         _result = (int )wxGridRangeSelectEvent_GetLeftCol(_arg0);
13502
13503     wxPy_END_ALLOW_THREADS;
13504     if (PyErr_Occurred()) return NULL;
13505 }    _resultobj = Py_BuildValue("i",_result);
13506     return _resultobj;
13507 }
13508
13509 #define wxGridRangeSelectEvent_GetRightCol(_swigobj)  (_swigobj->GetRightCol())
13510 static PyObject *_wrap_wxGridRangeSelectEvent_GetRightCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13511     PyObject * _resultobj;
13512     int  _result;
13513     wxGridRangeSelectEvent * _arg0;
13514     PyObject * _argo0 = 0;
13515     char *_kwnames[] = { "self", NULL };
13516
13517     self = self;
13518     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetRightCol",_kwnames,&_argo0))
13519         return NULL;
13520     if (_argo0) {
13521         if (_argo0 == Py_None) { _arg0 = NULL; }
13522         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13523             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetRightCol. Expected _wxGridRangeSelectEvent_p.");
13524         return NULL;
13525         }
13526     }
13527 {
13528     wxPy_BEGIN_ALLOW_THREADS;
13529         _result = (int )wxGridRangeSelectEvent_GetRightCol(_arg0);
13530
13531     wxPy_END_ALLOW_THREADS;
13532     if (PyErr_Occurred()) return NULL;
13533 }    _resultobj = Py_BuildValue("i",_result);
13534     return _resultobj;
13535 }
13536
13537 #define wxGridRangeSelectEvent_Selecting(_swigobj)  (_swigobj->Selecting())
13538 static PyObject *_wrap_wxGridRangeSelectEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
13539     PyObject * _resultobj;
13540     bool  _result;
13541     wxGridRangeSelectEvent * _arg0;
13542     PyObject * _argo0 = 0;
13543     char *_kwnames[] = { "self", NULL };
13544
13545     self = self;
13546     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_Selecting",_kwnames,&_argo0))
13547         return NULL;
13548     if (_argo0) {
13549         if (_argo0 == Py_None) { _arg0 = NULL; }
13550         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13551             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_Selecting. Expected _wxGridRangeSelectEvent_p.");
13552         return NULL;
13553         }
13554     }
13555 {
13556     wxPy_BEGIN_ALLOW_THREADS;
13557         _result = (bool )wxGridRangeSelectEvent_Selecting(_arg0);
13558
13559     wxPy_END_ALLOW_THREADS;
13560     if (PyErr_Occurred()) return NULL;
13561 }    _resultobj = Py_BuildValue("i",_result);
13562     return _resultobj;
13563 }
13564
13565 #define wxGridRangeSelectEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13566 static PyObject *_wrap_wxGridRangeSelectEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13567     PyObject * _resultobj;
13568     bool  _result;
13569     wxGridRangeSelectEvent * _arg0;
13570     PyObject * _argo0 = 0;
13571     char *_kwnames[] = { "self", NULL };
13572
13573     self = self;
13574     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ControlDown",_kwnames,&_argo0))
13575         return NULL;
13576     if (_argo0) {
13577         if (_argo0 == Py_None) { _arg0 = NULL; }
13578         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13579             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ControlDown. Expected _wxGridRangeSelectEvent_p.");
13580         return NULL;
13581         }
13582     }
13583 {
13584     wxPy_BEGIN_ALLOW_THREADS;
13585         _result = (bool )wxGridRangeSelectEvent_ControlDown(_arg0);
13586
13587     wxPy_END_ALLOW_THREADS;
13588     if (PyErr_Occurred()) return NULL;
13589 }    _resultobj = Py_BuildValue("i",_result);
13590     return _resultobj;
13591 }
13592
13593 #define wxGridRangeSelectEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13594 static PyObject *_wrap_wxGridRangeSelectEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13595     PyObject * _resultobj;
13596     bool  _result;
13597     wxGridRangeSelectEvent * _arg0;
13598     PyObject * _argo0 = 0;
13599     char *_kwnames[] = { "self", NULL };
13600
13601     self = self;
13602     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_MetaDown",_kwnames,&_argo0))
13603         return NULL;
13604     if (_argo0) {
13605         if (_argo0 == Py_None) { _arg0 = NULL; }
13606         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13607             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_MetaDown. Expected _wxGridRangeSelectEvent_p.");
13608         return NULL;
13609         }
13610     }
13611 {
13612     wxPy_BEGIN_ALLOW_THREADS;
13613         _result = (bool )wxGridRangeSelectEvent_MetaDown(_arg0);
13614
13615     wxPy_END_ALLOW_THREADS;
13616     if (PyErr_Occurred()) return NULL;
13617 }    _resultobj = Py_BuildValue("i",_result);
13618     return _resultobj;
13619 }
13620
13621 #define wxGridRangeSelectEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13622 static PyObject *_wrap_wxGridRangeSelectEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13623     PyObject * _resultobj;
13624     bool  _result;
13625     wxGridRangeSelectEvent * _arg0;
13626     PyObject * _argo0 = 0;
13627     char *_kwnames[] = { "self", NULL };
13628
13629     self = self;
13630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ShiftDown",_kwnames,&_argo0))
13631         return NULL;
13632     if (_argo0) {
13633         if (_argo0 == Py_None) { _arg0 = NULL; }
13634         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13635             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ShiftDown. Expected _wxGridRangeSelectEvent_p.");
13636         return NULL;
13637         }
13638     }
13639 {
13640     wxPy_BEGIN_ALLOW_THREADS;
13641         _result = (bool )wxGridRangeSelectEvent_ShiftDown(_arg0);
13642
13643     wxPy_END_ALLOW_THREADS;
13644     if (PyErr_Occurred()) return NULL;
13645 }    _resultobj = Py_BuildValue("i",_result);
13646     return _resultobj;
13647 }
13648
13649 #define wxGridRangeSelectEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13650 static PyObject *_wrap_wxGridRangeSelectEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13651     PyObject * _resultobj;
13652     bool  _result;
13653     wxGridRangeSelectEvent * _arg0;
13654     PyObject * _argo0 = 0;
13655     char *_kwnames[] = { "self", NULL };
13656
13657     self = self;
13658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_AltDown",_kwnames,&_argo0))
13659         return NULL;
13660     if (_argo0) {
13661         if (_argo0 == Py_None) { _arg0 = NULL; }
13662         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13663             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_AltDown. Expected _wxGridRangeSelectEvent_p.");
13664         return NULL;
13665         }
13666     }
13667 {
13668     wxPy_BEGIN_ALLOW_THREADS;
13669         _result = (bool )wxGridRangeSelectEvent_AltDown(_arg0);
13670
13671     wxPy_END_ALLOW_THREADS;
13672     if (PyErr_Occurred()) return NULL;
13673 }    _resultobj = Py_BuildValue("i",_result);
13674     return _resultobj;
13675 }
13676
13677 static void *SwigwxGridEditorCreatedEventTowxCommandEvent(void *ptr) {
13678     wxGridEditorCreatedEvent *src;
13679     wxCommandEvent *dest;
13680     src = (wxGridEditorCreatedEvent *) ptr;
13681     dest = (wxCommandEvent *) src;
13682     return (void *) dest;
13683 }
13684
13685 static void *SwigwxGridEditorCreatedEventTowxEvent(void *ptr) {
13686     wxGridEditorCreatedEvent *src;
13687     wxEvent *dest;
13688     src = (wxGridEditorCreatedEvent *) ptr;
13689     dest = (wxEvent *) src;
13690     return (void *) dest;
13691 }
13692
13693 static void *SwigwxGridEditorCreatedEventTowxObject(void *ptr) {
13694     wxGridEditorCreatedEvent *src;
13695     wxObject *dest;
13696     src = (wxGridEditorCreatedEvent *) ptr;
13697     dest = (wxObject *) src;
13698     return (void *) dest;
13699 }
13700
13701 #define new_wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
13702 static PyObject *_wrap_new_wxGridEditorCreatedEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13703     PyObject * _resultobj;
13704     wxGridEditorCreatedEvent * _result;
13705     int  _arg0;
13706     wxEventType  _arg1;
13707     wxObject * _arg2;
13708     int  _arg3;
13709     int  _arg4;
13710     wxControl * _arg5;
13711     PyObject * _argo2 = 0;
13712     PyObject * _argo5 = 0;
13713     char *_kwnames[] = { "id","type","obj","row","col","ctrl", NULL };
13714     char _ptemp[128];
13715
13716     self = self;
13717     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOiiO:new_wxGridEditorCreatedEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_argo5))
13718         return NULL;
13719     if (_argo2) {
13720         if (_argo2 == Py_None) { _arg2 = NULL; }
13721         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxObject_p")) {
13722             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEditorCreatedEvent. Expected _wxObject_p.");
13723         return NULL;
13724         }
13725     }
13726     if (_argo5) {
13727         if (_argo5 == Py_None) { _arg5 = NULL; }
13728         else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxControl_p")) {
13729             PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxGridEditorCreatedEvent. Expected _wxControl_p.");
13730         return NULL;
13731         }
13732     }
13733 {
13734     wxPy_BEGIN_ALLOW_THREADS;
13735         _result = (wxGridEditorCreatedEvent *)new_wxGridEditorCreatedEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
13736
13737     wxPy_END_ALLOW_THREADS;
13738     if (PyErr_Occurred()) return NULL;
13739 }    if (_result) {
13740         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEditorCreatedEvent_p");
13741         _resultobj = Py_BuildValue("s",_ptemp);
13742     } else {
13743         Py_INCREF(Py_None);
13744         _resultobj = Py_None;
13745     }
13746     return _resultobj;
13747 }
13748
13749 #define wxGridEditorCreatedEvent_GetRow(_swigobj)  (_swigobj->GetRow())
13750 static PyObject *_wrap_wxGridEditorCreatedEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13751     PyObject * _resultobj;
13752     int  _result;
13753     wxGridEditorCreatedEvent * _arg0;
13754     PyObject * _argo0 = 0;
13755     char *_kwnames[] = { "self", NULL };
13756
13757     self = self;
13758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetRow",_kwnames,&_argo0))
13759         return NULL;
13760     if (_argo0) {
13761         if (_argo0 == Py_None) { _arg0 = NULL; }
13762         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13763             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetRow. Expected _wxGridEditorCreatedEvent_p.");
13764         return NULL;
13765         }
13766     }
13767 {
13768     wxPy_BEGIN_ALLOW_THREADS;
13769         _result = (int )wxGridEditorCreatedEvent_GetRow(_arg0);
13770
13771     wxPy_END_ALLOW_THREADS;
13772     if (PyErr_Occurred()) return NULL;
13773 }    _resultobj = Py_BuildValue("i",_result);
13774     return _resultobj;
13775 }
13776
13777 #define wxGridEditorCreatedEvent_GetCol(_swigobj)  (_swigobj->GetCol())
13778 static PyObject *_wrap_wxGridEditorCreatedEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13779     PyObject * _resultobj;
13780     int  _result;
13781     wxGridEditorCreatedEvent * _arg0;
13782     PyObject * _argo0 = 0;
13783     char *_kwnames[] = { "self", NULL };
13784
13785     self = self;
13786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetCol",_kwnames,&_argo0))
13787         return NULL;
13788     if (_argo0) {
13789         if (_argo0 == Py_None) { _arg0 = NULL; }
13790         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13791             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetCol. Expected _wxGridEditorCreatedEvent_p.");
13792         return NULL;
13793         }
13794     }
13795 {
13796     wxPy_BEGIN_ALLOW_THREADS;
13797         _result = (int )wxGridEditorCreatedEvent_GetCol(_arg0);
13798
13799     wxPy_END_ALLOW_THREADS;
13800     if (PyErr_Occurred()) return NULL;
13801 }    _resultobj = Py_BuildValue("i",_result);
13802     return _resultobj;
13803 }
13804
13805 #define wxGridEditorCreatedEvent_GetControl(_swigobj)  (_swigobj->GetControl())
13806 static PyObject *_wrap_wxGridEditorCreatedEvent_GetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13807     PyObject * _resultobj;
13808     wxControl * _result;
13809     wxGridEditorCreatedEvent * _arg0;
13810     PyObject * _argo0 = 0;
13811     char *_kwnames[] = { "self", NULL };
13812
13813     self = self;
13814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetControl",_kwnames,&_argo0))
13815         return NULL;
13816     if (_argo0) {
13817         if (_argo0 == Py_None) { _arg0 = NULL; }
13818         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13819             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetControl. Expected _wxGridEditorCreatedEvent_p.");
13820         return NULL;
13821         }
13822     }
13823 {
13824     wxPy_BEGIN_ALLOW_THREADS;
13825         _result = (wxControl *)wxGridEditorCreatedEvent_GetControl(_arg0);
13826
13827     wxPy_END_ALLOW_THREADS;
13828     if (PyErr_Occurred()) return NULL;
13829 }{ _resultobj = wxPyMake_wxObject(_result); }
13830     return _resultobj;
13831 }
13832
13833 #define wxGridEditorCreatedEvent_SetRow(_swigobj,_swigarg0)  (_swigobj->SetRow(_swigarg0))
13834 static PyObject *_wrap_wxGridEditorCreatedEvent_SetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13835     PyObject * _resultobj;
13836     wxGridEditorCreatedEvent * _arg0;
13837     int  _arg1;
13838     PyObject * _argo0 = 0;
13839     char *_kwnames[] = { "self","row", NULL };
13840
13841     self = self;
13842     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetRow",_kwnames,&_argo0,&_arg1))
13843         return NULL;
13844     if (_argo0) {
13845         if (_argo0 == Py_None) { _arg0 = NULL; }
13846         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13847             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetRow. Expected _wxGridEditorCreatedEvent_p.");
13848         return NULL;
13849         }
13850     }
13851 {
13852     wxPy_BEGIN_ALLOW_THREADS;
13853         wxGridEditorCreatedEvent_SetRow(_arg0,_arg1);
13854
13855     wxPy_END_ALLOW_THREADS;
13856     if (PyErr_Occurred()) return NULL;
13857 }    Py_INCREF(Py_None);
13858     _resultobj = Py_None;
13859     return _resultobj;
13860 }
13861
13862 #define wxGridEditorCreatedEvent_SetCol(_swigobj,_swigarg0)  (_swigobj->SetCol(_swigarg0))
13863 static PyObject *_wrap_wxGridEditorCreatedEvent_SetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13864     PyObject * _resultobj;
13865     wxGridEditorCreatedEvent * _arg0;
13866     int  _arg1;
13867     PyObject * _argo0 = 0;
13868     char *_kwnames[] = { "self","col", NULL };
13869
13870     self = self;
13871     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetCol",_kwnames,&_argo0,&_arg1))
13872         return NULL;
13873     if (_argo0) {
13874         if (_argo0 == Py_None) { _arg0 = NULL; }
13875         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13876             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetCol. Expected _wxGridEditorCreatedEvent_p.");
13877         return NULL;
13878         }
13879     }
13880 {
13881     wxPy_BEGIN_ALLOW_THREADS;
13882         wxGridEditorCreatedEvent_SetCol(_arg0,_arg1);
13883
13884     wxPy_END_ALLOW_THREADS;
13885     if (PyErr_Occurred()) return NULL;
13886 }    Py_INCREF(Py_None);
13887     _resultobj = Py_None;
13888     return _resultobj;
13889 }
13890
13891 #define wxGridEditorCreatedEvent_SetControl(_swigobj,_swigarg0)  (_swigobj->SetControl(_swigarg0))
13892 static PyObject *_wrap_wxGridEditorCreatedEvent_SetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13893     PyObject * _resultobj;
13894     wxGridEditorCreatedEvent * _arg0;
13895     wxControl * _arg1;
13896     PyObject * _argo0 = 0;
13897     PyObject * _argo1 = 0;
13898     char *_kwnames[] = { "self","ctrl", NULL };
13899
13900     self = self;
13901     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridEditorCreatedEvent_SetControl",_kwnames,&_argo0,&_argo1))
13902         return NULL;
13903     if (_argo0) {
13904         if (_argo0 == Py_None) { _arg0 = NULL; }
13905         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13906             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetControl. Expected _wxGridEditorCreatedEvent_p.");
13907         return NULL;
13908         }
13909     }
13910     if (_argo1) {
13911         if (_argo1 == Py_None) { _arg1 = NULL; }
13912         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxControl_p")) {
13913             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridEditorCreatedEvent_SetControl. Expected _wxControl_p.");
13914         return NULL;
13915         }
13916     }
13917 {
13918     wxPy_BEGIN_ALLOW_THREADS;
13919         wxGridEditorCreatedEvent_SetControl(_arg0,_arg1);
13920
13921     wxPy_END_ALLOW_THREADS;
13922     if (PyErr_Occurred()) return NULL;
13923 }    Py_INCREF(Py_None);
13924     _resultobj = Py_None;
13925     return _resultobj;
13926 }
13927
13928 static PyMethodDef gridcMethods[] = {
13929          { "wxGridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS },
13930          { "wxGridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS },
13931          { "wxGridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS },
13932          { "wxGridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS },
13933          { "wxGridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
13934          { "wxGridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
13935          { "new_wxGridEditorCreatedEvent", (PyCFunction) _wrap_new_wxGridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS },
13936          { "wxGridRangeSelectEvent_AltDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13937          { "wxGridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13938          { "wxGridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13939          { "wxGridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13940          { "wxGridRangeSelectEvent_Selecting", (PyCFunction) _wrap_wxGridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
13941          { "wxGridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS },
13942          { "wxGridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS },
13943          { "wxGridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS },
13944          { "wxGridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS },
13945          { "wxGridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS },
13946          { "wxGridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS },
13947          { "new_wxGridRangeSelectEvent", (PyCFunction) _wrap_new_wxGridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS },
13948          { "wxGridSizeEvent_AltDown", (PyCFunction) _wrap_wxGridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13949          { "wxGridSizeEvent_ShiftDown", (PyCFunction) _wrap_wxGridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13950          { "wxGridSizeEvent_MetaDown", (PyCFunction) _wrap_wxGridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13951          { "wxGridSizeEvent_ControlDown", (PyCFunction) _wrap_wxGridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13952          { "wxGridSizeEvent_GetPosition", (PyCFunction) _wrap_wxGridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
13953          { "wxGridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_wxGridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS },
13954          { "new_wxGridSizeEvent", (PyCFunction) _wrap_new_wxGridSizeEvent, METH_VARARGS | METH_KEYWORDS },
13955          { "wxGridEvent_AltDown", (PyCFunction) _wrap_wxGridEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13956          { "wxGridEvent_ShiftDown", (PyCFunction) _wrap_wxGridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13957          { "wxGridEvent_MetaDown", (PyCFunction) _wrap_wxGridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13958          { "wxGridEvent_ControlDown", (PyCFunction) _wrap_wxGridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13959          { "wxGridEvent_Selecting", (PyCFunction) _wrap_wxGridEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
13960          { "wxGridEvent_GetPosition", (PyCFunction) _wrap_wxGridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
13961          { "wxGridEvent_GetCol", (PyCFunction) _wrap_wxGridEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
13962          { "wxGridEvent_GetRow", (PyCFunction) _wrap_wxGridEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
13963          { "new_wxGridEvent", (PyCFunction) _wrap_new_wxGridEvent, METH_VARARGS | METH_KEYWORDS },
13964          { "wxGrid_GetGridCornerLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS },
13965          { "wxGrid_GetGridColLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS },
13966          { "wxGrid_GetGridRowLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS },
13967          { "wxGrid_GetGridWindow", (PyCFunction) _wrap_wxGrid_GetGridWindow, METH_VARARGS | METH_KEYWORDS },
13968          { "wxGrid_SetMargins", (PyCFunction) _wrap_wxGrid_SetMargins, METH_VARARGS | METH_KEYWORDS },
13969          { "wxGrid_GetDefaultRendererForType", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS },
13970          { "wxGrid_GetDefaultEditorForType", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS },
13971          { "wxGrid_GetDefaultRendererForCell", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS },
13972          { "wxGrid_GetDefaultEditorForCell", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS },
13973          { "wxGrid_RegisterDataType", (PyCFunction) _wrap_wxGrid_RegisterDataType, METH_VARARGS | METH_KEYWORDS },
13974          { "wxGrid_SetSelectionForeground", (PyCFunction) _wrap_wxGrid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
13975          { "wxGrid_SetSelectionBackground", (PyCFunction) _wrap_wxGrid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
13976          { "wxGrid_GetSelectionForeground", (PyCFunction) _wrap_wxGrid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
13977          { "wxGrid_GetSelectionBackground", (PyCFunction) _wrap_wxGrid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
13978          { "wxGrid_BlockToDeviceRect", (PyCFunction) _wrap_wxGrid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS },
13979          { "wxGrid_IsInSelection", (PyCFunction) _wrap_wxGrid_IsInSelection, METH_VARARGS | METH_KEYWORDS },
13980          { "wxGrid_ClearSelection", (PyCFunction) _wrap_wxGrid_ClearSelection, METH_VARARGS | METH_KEYWORDS },
13981          { "wxGrid_IsSelection", (PyCFunction) _wrap_wxGrid_IsSelection, METH_VARARGS | METH_KEYWORDS },
13982          { "wxGrid_SelectAll", (PyCFunction) _wrap_wxGrid_SelectAll, METH_VARARGS | METH_KEYWORDS },
13983          { "wxGrid_SelectBlock", (PyCFunction) _wrap_wxGrid_SelectBlock, METH_VARARGS | METH_KEYWORDS },
13984          { "wxGrid_SelectCol", (PyCFunction) _wrap_wxGrid_SelectCol, METH_VARARGS | METH_KEYWORDS },
13985          { "wxGrid_SelectRow", (PyCFunction) _wrap_wxGrid_SelectRow, METH_VARARGS | METH_KEYWORDS },
13986          { "wxGrid_SetReadOnly", (PyCFunction) _wrap_wxGrid_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
13987          { "wxGrid_IsReadOnly", (PyCFunction) _wrap_wxGrid_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
13988          { "wxGrid_SetCellValue", (PyCFunction) _wrap_wxGrid_SetCellValue, METH_VARARGS | METH_KEYWORDS },
13989          { "wxGrid_GetCellValue", (PyCFunction) _wrap_wxGrid_GetCellValue, METH_VARARGS | METH_KEYWORDS },
13990          { "wxGrid_GetCellEditor", (PyCFunction) _wrap_wxGrid_GetCellEditor, METH_VARARGS | METH_KEYWORDS },
13991          { "wxGrid_GetDefaultEditor", (PyCFunction) _wrap_wxGrid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
13992          { "wxGrid_SetCellEditor", (PyCFunction) _wrap_wxGrid_SetCellEditor, METH_VARARGS | METH_KEYWORDS },
13993          { "wxGrid_SetDefaultEditor", (PyCFunction) _wrap_wxGrid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
13994          { "wxGrid_GetCellRenderer", (PyCFunction) _wrap_wxGrid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS },
13995          { "wxGrid_GetDefaultRenderer", (PyCFunction) _wrap_wxGrid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
13996          { "wxGrid_SetCellRenderer", (PyCFunction) _wrap_wxGrid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS },
13997          { "wxGrid_SetDefaultRenderer", (PyCFunction) _wrap_wxGrid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
13998          { "wxGrid_SetCellAlignment", (PyCFunction) _wrap_wxGrid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS },
13999          { "wxGrid_SetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14000          { "wxGrid_SetCellFont", (PyCFunction) _wrap_wxGrid_SetCellFont, METH_VARARGS | METH_KEYWORDS },
14001          { "wxGrid_SetDefaultCellFont", (PyCFunction) _wrap_wxGrid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14002          { "wxGrid_SetCellTextColour", (PyCFunction) _wrap_wxGrid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14003          { "wxGrid_SetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14004          { "wxGrid_SetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14005          { "wxGrid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14006          { "wxGrid_SetRowMinimalHeight", (PyCFunction) _wrap_wxGrid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS },
14007          { "wxGrid_SetColMinimalWidth", (PyCFunction) _wrap_wxGrid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS },
14008          { "wxGrid_AutoSize", (PyCFunction) _wrap_wxGrid_AutoSize, METH_VARARGS | METH_KEYWORDS },
14009          { "wxGrid_AutoSizeRows", (PyCFunction) _wrap_wxGrid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS },
14010          { "wxGrid_AutoSizeColumns", (PyCFunction) _wrap_wxGrid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS },
14011          { "wxGrid_AutoSizeRow", (PyCFunction) _wrap_wxGrid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS },
14012          { "wxGrid_AutoSizeColumn", (PyCFunction) _wrap_wxGrid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS },
14013          { "wxGrid_SetColSize", (PyCFunction) _wrap_wxGrid_SetColSize, METH_VARARGS | METH_KEYWORDS },
14014          { "wxGrid_SetDefaultColSize", (PyCFunction) _wrap_wxGrid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14015          { "wxGrid_SetRowSize", (PyCFunction) _wrap_wxGrid_SetRowSize, METH_VARARGS | METH_KEYWORDS },
14016          { "wxGrid_SetDefaultRowSize", (PyCFunction) _wrap_wxGrid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14017          { "wxGrid_GetCellAlignment", (PyCFunction) _wrap_wxGrid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS },
14018          { "wxGrid_GetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14019          { "wxGrid_GetCellFont", (PyCFunction) _wrap_wxGrid_GetCellFont, METH_VARARGS | METH_KEYWORDS },
14020          { "wxGrid_GetDefaultCellFont", (PyCFunction) _wrap_wxGrid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14021          { "wxGrid_GetCellTextColour", (PyCFunction) _wrap_wxGrid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14022          { "wxGrid_GetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14023          { "wxGrid_GetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14024          { "wxGrid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14025          { "wxGrid_GetColSize", (PyCFunction) _wrap_wxGrid_GetColSize, METH_VARARGS | METH_KEYWORDS },
14026          { "wxGrid_GetDefaultColSize", (PyCFunction) _wrap_wxGrid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14027          { "wxGrid_GetRowSize", (PyCFunction) _wrap_wxGrid_GetRowSize, METH_VARARGS | METH_KEYWORDS },
14028          { "wxGrid_GetDefaultRowSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14029          { "wxGrid_GridLinesEnabled", (PyCFunction) _wrap_wxGrid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS },
14030          { "wxGrid_EnableGridLines", (PyCFunction) _wrap_wxGrid_EnableGridLines, METH_VARARGS | METH_KEYWORDS },
14031          { "wxGrid_SetColFormatCustom", (PyCFunction) _wrap_wxGrid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS },
14032          { "wxGrid_SetColFormatFloat", (PyCFunction) _wrap_wxGrid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS },
14033          { "wxGrid_SetColFormatNumber", (PyCFunction) _wrap_wxGrid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS },
14034          { "wxGrid_SetColFormatBool", (PyCFunction) _wrap_wxGrid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS },
14035          { "wxGrid_SetColAttr", (PyCFunction) _wrap_wxGrid_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14036          { "wxGrid_SetRowAttr", (PyCFunction) _wrap_wxGrid_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14037          { "wxGrid_CanDragGridSize", (PyCFunction) _wrap_wxGrid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS },
14038          { "wxGrid_DisableDragGridSize", (PyCFunction) _wrap_wxGrid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14039          { "wxGrid_EnableDragGridSize", (PyCFunction) _wrap_wxGrid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14040          { "wxGrid_CanDragColSize", (PyCFunction) _wrap_wxGrid_CanDragColSize, METH_VARARGS | METH_KEYWORDS },
14041          { "wxGrid_DisableDragColSize", (PyCFunction) _wrap_wxGrid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS },
14042          { "wxGrid_EnableDragColSize", (PyCFunction) _wrap_wxGrid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS },
14043          { "wxGrid_CanDragRowSize", (PyCFunction) _wrap_wxGrid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS },
14044          { "wxGrid_DisableDragRowSize", (PyCFunction) _wrap_wxGrid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14045          { "wxGrid_EnableDragRowSize", (PyCFunction) _wrap_wxGrid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14046          { "wxGrid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14047          { "wxGrid_SetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14048          { "wxGrid_SetCellHighlightColour", (PyCFunction) _wrap_wxGrid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14049          { "wxGrid_SetGridLineColour", (PyCFunction) _wrap_wxGrid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14050          { "wxGrid_SetColLabelValue", (PyCFunction) _wrap_wxGrid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14051          { "wxGrid_SetRowLabelValue", (PyCFunction) _wrap_wxGrid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14052          { "wxGrid_SetColLabelAlignment", (PyCFunction) _wrap_wxGrid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14053          { "wxGrid_SetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14054          { "wxGrid_SetLabelFont", (PyCFunction) _wrap_wxGrid_SetLabelFont, METH_VARARGS | METH_KEYWORDS },
14055          { "wxGrid_SetLabelTextColour", (PyCFunction) _wrap_wxGrid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14056          { "wxGrid_SetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14057          { "wxGrid_SetColLabelSize", (PyCFunction) _wrap_wxGrid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14058          { "wxGrid_SetRowLabelSize", (PyCFunction) _wrap_wxGrid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14059          { "wxGrid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14060          { "wxGrid_GetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14061          { "wxGrid_GetCellHighlightColour", (PyCFunction) _wrap_wxGrid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14062          { "wxGrid_GetGridLineColour", (PyCFunction) _wrap_wxGrid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14063          { "wxGrid_GetColLabelValue", (PyCFunction) _wrap_wxGrid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14064          { "wxGrid_GetRowLabelValue", (PyCFunction) _wrap_wxGrid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14065          { "wxGrid_GetColLabelAlignment", (PyCFunction) _wrap_wxGrid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14066          { "wxGrid_GetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14067          { "wxGrid_GetLabelFont", (PyCFunction) _wrap_wxGrid_GetLabelFont, METH_VARARGS | METH_KEYWORDS },
14068          { "wxGrid_GetLabelTextColour", (PyCFunction) _wrap_wxGrid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14069          { "wxGrid_GetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14070          { "wxGrid_GetColLabelSize", (PyCFunction) _wrap_wxGrid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14071          { "wxGrid_GetDefaultColLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS },
14072          { "wxGrid_GetRowLabelSize", (PyCFunction) _wrap_wxGrid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14073          { "wxGrid_GetDefaultRowLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14074          { "wxGrid_MoveCursorRightBlock", (PyCFunction) _wrap_wxGrid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS },
14075          { "wxGrid_MoveCursorLeftBlock", (PyCFunction) _wrap_wxGrid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS },
14076          { "wxGrid_MoveCursorDownBlock", (PyCFunction) _wrap_wxGrid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS },
14077          { "wxGrid_MoveCursorUpBlock", (PyCFunction) _wrap_wxGrid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS },
14078          { "wxGrid_MovePageUp", (PyCFunction) _wrap_wxGrid_MovePageUp, METH_VARARGS | METH_KEYWORDS },
14079          { "wxGrid_MovePageDown", (PyCFunction) _wrap_wxGrid_MovePageDown, METH_VARARGS | METH_KEYWORDS },
14080          { "wxGrid_MoveCursorRight", (PyCFunction) _wrap_wxGrid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS },
14081          { "wxGrid_MoveCursorLeft", (PyCFunction) _wrap_wxGrid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS },
14082          { "wxGrid_MoveCursorDown", (PyCFunction) _wrap_wxGrid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS },
14083          { "wxGrid_MoveCursorUp", (PyCFunction) _wrap_wxGrid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS },
14084          { "wxGrid_SetGridCursor", (PyCFunction) _wrap_wxGrid_SetGridCursor, METH_VARARGS | METH_KEYWORDS },
14085          { "wxGrid_MakeCellVisible", (PyCFunction) _wrap_wxGrid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS },
14086          { "wxGrid_IsVisible", (PyCFunction) _wrap_wxGrid_IsVisible, METH_VARARGS | METH_KEYWORDS },
14087          { "wxGrid_GetGridCursorCol", (PyCFunction) _wrap_wxGrid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS },
14088          { "wxGrid_GetGridCursorRow", (PyCFunction) _wrap_wxGrid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS },
14089          { "wxGrid_CellToRect", (PyCFunction) _wrap_wxGrid_CellToRect, METH_VARARGS | METH_KEYWORDS },
14090          { "wxGrid_XToEdgeOfCol", (PyCFunction) _wrap_wxGrid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS },
14091          { "wxGrid_YToEdgeOfRow", (PyCFunction) _wrap_wxGrid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS },
14092          { "wxGrid_XToCol", (PyCFunction) _wrap_wxGrid_XToCol, METH_VARARGS | METH_KEYWORDS },
14093          { "wxGrid_YToRow", (PyCFunction) _wrap_wxGrid_YToRow, METH_VARARGS | METH_KEYWORDS },
14094          { "wxGrid_XYToCell", (PyCFunction) _wrap_wxGrid_XYToCell, METH_VARARGS | METH_KEYWORDS },
14095          { "wxGrid_SaveEditControlValue", (PyCFunction) _wrap_wxGrid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS },
14096          { "wxGrid_HideCellEditControl", (PyCFunction) _wrap_wxGrid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS },
14097          { "wxGrid_ShowCellEditControl", (PyCFunction) _wrap_wxGrid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS },
14098          { "wxGrid_IsCurrentCellReadOnly", (PyCFunction) _wrap_wxGrid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS },
14099          { "wxGrid_IsCellEditControlShown", (PyCFunction) _wrap_wxGrid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS },
14100          { "wxGrid_IsCellEditControlEnabled", (PyCFunction) _wrap_wxGrid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS },
14101          { "wxGrid_CanEnableCellControl", (PyCFunction) _wrap_wxGrid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS },
14102          { "wxGrid_DisableCellEditControl", (PyCFunction) _wrap_wxGrid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14103          { "wxGrid_EnableCellEditControl", (PyCFunction) _wrap_wxGrid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14104          { "wxGrid_EnableEditing", (PyCFunction) _wrap_wxGrid_EnableEditing, METH_VARARGS | METH_KEYWORDS },
14105          { "wxGrid_IsEditable", (PyCFunction) _wrap_wxGrid_IsEditable, METH_VARARGS | METH_KEYWORDS },
14106          { "wxGrid_ForceRefresh", (PyCFunction) _wrap_wxGrid_ForceRefresh, METH_VARARGS | METH_KEYWORDS },
14107          { "wxGrid_GetBatchCount", (PyCFunction) _wrap_wxGrid_GetBatchCount, METH_VARARGS | METH_KEYWORDS },
14108          { "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
14109          { "wxGrid_BeginBatch", (PyCFunction) _wrap_wxGrid_BeginBatch, METH_VARARGS | METH_KEYWORDS },
14110          { "wxGrid_GetTextBoxSize", (PyCFunction) _wrap_wxGrid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS },
14111          { "wxGrid_DrawTextRectangle", (PyCFunction) _wrap_wxGrid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS },
14112          { "wxGrid_DrawCellHighlight", (PyCFunction) _wrap_wxGrid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS },
14113          { "wxGrid_DeleteCols", (PyCFunction) _wrap_wxGrid_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14114          { "wxGrid_AppendCols", (PyCFunction) _wrap_wxGrid_AppendCols, METH_VARARGS | METH_KEYWORDS },
14115          { "wxGrid_InsertCols", (PyCFunction) _wrap_wxGrid_InsertCols, METH_VARARGS | METH_KEYWORDS },
14116          { "wxGrid_DeleteRows", (PyCFunction) _wrap_wxGrid_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14117          { "wxGrid_AppendRows", (PyCFunction) _wrap_wxGrid_AppendRows, METH_VARARGS | METH_KEYWORDS },
14118          { "wxGrid_InsertRows", (PyCFunction) _wrap_wxGrid_InsertRows, METH_VARARGS | METH_KEYWORDS },
14119          { "wxGrid_ClearGrid", (PyCFunction) _wrap_wxGrid_ClearGrid, METH_VARARGS | METH_KEYWORDS },
14120          { "wxGrid_SetTable", (PyCFunction) _wrap_wxGrid_SetTable, METH_VARARGS | METH_KEYWORDS },
14121          { "wxGrid_GetTable", (PyCFunction) _wrap_wxGrid_GetTable, METH_VARARGS | METH_KEYWORDS },
14122          { "wxGrid_ProcessTableMessage", (PyCFunction) _wrap_wxGrid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS },
14123          { "wxGrid_GetNumberCols", (PyCFunction) _wrap_wxGrid_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14124          { "wxGrid_GetNumberRows", (PyCFunction) _wrap_wxGrid_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14125          { "wxGrid_SetSelectionMode", (PyCFunction) _wrap_wxGrid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS },
14126          { "wxGrid_CreateGrid", (PyCFunction) _wrap_wxGrid_CreateGrid, METH_VARARGS | METH_KEYWORDS },
14127          { "new_wxGrid", (PyCFunction) _wrap_new_wxGrid, METH_VARARGS | METH_KEYWORDS },
14128          { "wxGridCellCoords___cmp__", (PyCFunction) _wrap_wxGridCellCoords___cmp__, METH_VARARGS | METH_KEYWORDS },
14129          { "wxGridCellCoords_asTuple", (PyCFunction) _wrap_wxGridCellCoords_asTuple, METH_VARARGS | METH_KEYWORDS },
14130          { "wxGridCellCoords_Set", (PyCFunction) _wrap_wxGridCellCoords_Set, METH_VARARGS | METH_KEYWORDS },
14131          { "wxGridCellCoords_SetCol", (PyCFunction) _wrap_wxGridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS },
14132          { "wxGridCellCoords_GetCol", (PyCFunction) _wrap_wxGridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS },
14133          { "wxGridCellCoords_SetRow", (PyCFunction) _wrap_wxGridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS },
14134          { "wxGridCellCoords_GetRow", (PyCFunction) _wrap_wxGridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS },
14135          { "delete_wxGridCellCoords", (PyCFunction) _wrap_delete_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14136          { "new_wxGridCellCoords", (PyCFunction) _wrap_new_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14137          { "wxGridTableMessage_GetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14138          { "wxGridTableMessage_SetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14139          { "wxGridTableMessage_GetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS },
14140          { "wxGridTableMessage_SetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS },
14141          { "wxGridTableMessage_GetId", (PyCFunction) _wrap_wxGridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS },
14142          { "wxGridTableMessage_SetId", (PyCFunction) _wrap_wxGridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS },
14143          { "wxGridTableMessage_GetTableObject", (PyCFunction) _wrap_wxGridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS },
14144          { "wxGridTableMessage_SetTableObject", (PyCFunction) _wrap_wxGridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS },
14145          { "delete_wxGridTableMessage", (PyCFunction) _wrap_delete_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14146          { "new_wxGridTableMessage", (PyCFunction) _wrap_new_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14147          { "new_wxGridStringTable", (PyCFunction) _wrap_new_wxGridStringTable, METH_VARARGS | METH_KEYWORDS },
14148          { "wxPyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14149          { "wxPyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14150          { "wxPyGridTableBase_base_SetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14151          { "wxPyGridTableBase_base_GetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14152          { "wxPyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_wxPyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14153          { "wxPyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14154          { "wxPyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14155          { "wxPyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14156          { "wxPyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14157          { "wxPyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14158          { "wxPyGridTableBase_base_AppendCols", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS },
14159          { "wxPyGridTableBase_base_InsertCols", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS },
14160          { "wxPyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14161          { "wxPyGridTableBase_base_AppendRows", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS },
14162          { "wxPyGridTableBase_base_InsertRows", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS },
14163          { "wxPyGridTableBase_base_Clear", (PyCFunction) _wrap_wxPyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS },
14164          { "wxPyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14165          { "wxPyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14166          { "wxPyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_wxPyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14167          { "wxPyGridTableBase_Destroy", (PyCFunction) _wrap_wxPyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS },
14168          { "wxPyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_wxPyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14169          { "new_wxPyGridTableBase", (PyCFunction) _wrap_new_wxPyGridTableBase, METH_VARARGS | METH_KEYWORDS },
14170          { "wxGridTableBase_SetColAttr", (PyCFunction) _wrap_wxGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14171          { "wxGridTableBase_SetRowAttr", (PyCFunction) _wrap_wxGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14172          { "wxGridTableBase_SetAttr", (PyCFunction) _wrap_wxGridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS },
14173          { "wxGridTableBase_GetAttr", (PyCFunction) _wrap_wxGridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS },
14174          { "wxGridTableBase_CanHaveAttributes", (PyCFunction) _wrap_wxGridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14175          { "wxGridTableBase_SetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14176          { "wxGridTableBase_SetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14177          { "wxGridTableBase_GetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14178          { "wxGridTableBase_GetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14179          { "wxGridTableBase_DeleteCols", (PyCFunction) _wrap_wxGridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14180          { "wxGridTableBase_AppendCols", (PyCFunction) _wrap_wxGridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS },
14181          { "wxGridTableBase_InsertCols", (PyCFunction) _wrap_wxGridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS },
14182          { "wxGridTableBase_DeleteRows", (PyCFunction) _wrap_wxGridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14183          { "wxGridTableBase_AppendRows", (PyCFunction) _wrap_wxGridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS },
14184          { "wxGridTableBase_InsertRows", (PyCFunction) _wrap_wxGridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS },
14185          { "wxGridTableBase_Clear", (PyCFunction) _wrap_wxGridTableBase_Clear, METH_VARARGS | METH_KEYWORDS },
14186          { "wxGridTableBase_SetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14187          { "wxGridTableBase_SetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14188          { "wxGridTableBase_SetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14189          { "wxGridTableBase_GetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14190          { "wxGridTableBase_GetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14191          { "wxGridTableBase_GetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14192          { "wxGridTableBase_CanSetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14193          { "wxGridTableBase_CanGetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14194          { "wxGridTableBase_GetTypeName", (PyCFunction) _wrap_wxGridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14195          { "wxGridTableBase_SetValue", (PyCFunction) _wrap_wxGridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS },
14196          { "wxGridTableBase_GetValue", (PyCFunction) _wrap_wxGridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS },
14197          { "wxGridTableBase_IsEmptyCell", (PyCFunction) _wrap_wxGridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS },
14198          { "wxGridTableBase_GetNumberCols", (PyCFunction) _wrap_wxGridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14199          { "wxGridTableBase_GetNumberRows", (PyCFunction) _wrap_wxGridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14200          { "wxGridTableBase_GetView", (PyCFunction) _wrap_wxGridTableBase_GetView, METH_VARARGS | METH_KEYWORDS },
14201          { "wxGridTableBase_SetView", (PyCFunction) _wrap_wxGridTableBase_SetView, METH_VARARGS | METH_KEYWORDS },
14202          { "wxGridTableBase_GetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14203          { "wxGridTableBase_SetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14204          { "wxPyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14205          { "wxPyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14206          { "wxPyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14207          { "wxPyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14208          { "wxPyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14209          { "new_wxPyGridCellAttrProvider", (PyCFunction) _wrap_new_wxPyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14210          { "wxGridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS },
14211          { "wxGridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS },
14212          { "wxGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14213          { "wxGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14214          { "wxGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS },
14215          { "wxGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS },
14216          { "new_wxGridCellAttrProvider", (PyCFunction) _wrap_new_wxGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14217          { "wxGridCellAttr_SetDefAttr", (PyCFunction) _wrap_wxGridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS },
14218          { "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
14219          { "wxGridCellAttr_GetEditor", (PyCFunction) _wrap_wxGridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS },
14220          { "wxGridCellAttr_GetRenderer", (PyCFunction) _wrap_wxGridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS },
14221          { "wxGridCellAttr_GetAlignment", (PyCFunction) _wrap_wxGridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS },
14222          { "wxGridCellAttr_GetFont", (PyCFunction) _wrap_wxGridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS },
14223          { "wxGridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14224          { "wxGridCellAttr_GetTextColour", (PyCFunction) _wrap_wxGridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS },
14225          { "wxGridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_wxGridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS },
14226          { "wxGridCellAttr_HasEditor", (PyCFunction) _wrap_wxGridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS },
14227          { "wxGridCellAttr_HasRenderer", (PyCFunction) _wrap_wxGridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS },
14228          { "wxGridCellAttr_HasAlignment", (PyCFunction) _wrap_wxGridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS },
14229          { "wxGridCellAttr_HasFont", (PyCFunction) _wrap_wxGridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS },
14230          { "wxGridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14231          { "wxGridCellAttr_HasTextColour", (PyCFunction) _wrap_wxGridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS },
14232          { "wxGridCellAttr_SetKind", (PyCFunction) _wrap_wxGridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS },
14233          { "wxGridCellAttr_SetEditor", (PyCFunction) _wrap_wxGridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS },
14234          { "wxGridCellAttr_SetRenderer", (PyCFunction) _wrap_wxGridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS },
14235          { "wxGridCellAttr_SetReadOnly", (PyCFunction) _wrap_wxGridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
14236          { "wxGridCellAttr_SetAlignment", (PyCFunction) _wrap_wxGridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS },
14237          { "wxGridCellAttr_SetFont", (PyCFunction) _wrap_wxGridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS },
14238          { "wxGridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14239          { "wxGridCellAttr_SetTextColour", (PyCFunction) _wrap_wxGridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS },
14240          { "wxGridCellAttr_DecRef", (PyCFunction) _wrap_wxGridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS },
14241          { "wxGridCellAttr_IncRef", (PyCFunction) _wrap_wxGridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS },
14242          { "wxGridCellAttr_MergeWith", (PyCFunction) _wrap_wxGridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS },
14243          { "wxGridCellAttr_Clone", (PyCFunction) _wrap_wxGridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS },
14244          { "new_wxGridCellAttr", (PyCFunction) _wrap_new_wxGridCellAttr, METH_VARARGS | METH_KEYWORDS },
14245          { "new_wxGridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS },
14246          { "new_wxGridCellEnumEditor", (PyCFunction) _wrap_new_wxGridCellEnumEditor, METH_VARARGS | METH_KEYWORDS },
14247          { "new_wxGridCellChoiceEditor", (PyCFunction) _wrap_new_wxGridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS },
14248          { "new_wxGridCellBoolEditor", (PyCFunction) _wrap_new_wxGridCellBoolEditor, METH_VARARGS | METH_KEYWORDS },
14249          { "new_wxGridCellFloatEditor", (PyCFunction) _wrap_new_wxGridCellFloatEditor, METH_VARARGS | METH_KEYWORDS },
14250          { "new_wxGridCellNumberEditor", (PyCFunction) _wrap_new_wxGridCellNumberEditor, METH_VARARGS | METH_KEYWORDS },
14251          { "new_wxGridCellTextEditor", (PyCFunction) _wrap_new_wxGridCellTextEditor, METH_VARARGS | METH_KEYWORDS },
14252          { "wxPyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14253          { "wxPyGridCellEditor_base_Destroy", (PyCFunction) _wrap_wxPyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS },
14254          { "wxPyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_wxPyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14255          { "wxPyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS },
14256          { "wxPyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS },
14257          { "wxPyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14258          { "wxPyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_wxPyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14259          { "wxPyGridCellEditor_base_Show", (PyCFunction) _wrap_wxPyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS },
14260          { "wxPyGridCellEditor_base_SetSize", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS },
14261          { "wxPyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14262          { "new_wxPyGridCellEditor", (PyCFunction) _wrap_new_wxPyGridCellEditor, METH_VARARGS | METH_KEYWORDS },
14263          { "wxGridCellEditor_Destroy", (PyCFunction) _wrap_wxGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS },
14264          { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14265          { "wxGridCellEditor_StartingClick", (PyCFunction) _wrap_wxGridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS },
14266          { "wxGridCellEditor_StartingKey", (PyCFunction) _wrap_wxGridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS },
14267          { "wxGridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_wxGridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14268          { "wxGridCellEditor_PaintBackground", (PyCFunction) _wrap_wxGridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14269          { "wxGridCellEditor_Show", (PyCFunction) _wrap_wxGridCellEditor_Show, METH_VARARGS | METH_KEYWORDS },
14270          { "wxGridCellEditor_SetSize", (PyCFunction) _wrap_wxGridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS },
14271          { "wxGridCellEditor_Clone", (PyCFunction) _wrap_wxGridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS },
14272          { "wxGridCellEditor_Reset", (PyCFunction) _wrap_wxGridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS },
14273          { "wxGridCellEditor_EndEdit", (PyCFunction) _wrap_wxGridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS },
14274          { "wxGridCellEditor_BeginEdit", (PyCFunction) _wrap_wxGridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS },
14275          { "wxGridCellEditor_Create", (PyCFunction) _wrap_wxGridCellEditor_Create, METH_VARARGS | METH_KEYWORDS },
14276          { "wxGridCellEditor_DecRef", (PyCFunction) _wrap_wxGridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS },
14277          { "wxGridCellEditor_IncRef", (PyCFunction) _wrap_wxGridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS },
14278          { "wxGridCellEditor_SetParameters", (PyCFunction) _wrap_wxGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS },
14279          { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS },
14280          { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS },
14281          { "wxGridCellEditor_IsCreated", (PyCFunction) _wrap_wxGridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS },
14282          { "new_wxGridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS },
14283          { "new_wxGridCellEnumRenderer", (PyCFunction) _wrap_new_wxGridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS },
14284          { "new_wxGridCellDateTimeRenderer", (PyCFunction) _wrap_new_wxGridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS },
14285          { "new_wxGridCellBoolRenderer", (PyCFunction) _wrap_new_wxGridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS },
14286          { "wxGridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS },
14287          { "wxGridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS },
14288          { "wxGridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS },
14289          { "wxGridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS },
14290          { "new_wxGridCellFloatRenderer", (PyCFunction) _wrap_new_wxGridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS },
14291          { "new_wxGridCellNumberRenderer", (PyCFunction) _wrap_new_wxGridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS },
14292          { "new_wxGridCellStringRenderer", (PyCFunction) _wrap_new_wxGridCellStringRenderer, METH_VARARGS | METH_KEYWORDS },
14293          { "wxPyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14294          { "wxPyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14295          { "new_wxPyGridCellRenderer", (PyCFunction) _wrap_new_wxPyGridCellRenderer, METH_VARARGS | METH_KEYWORDS },
14296          { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS },
14297          { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS },
14298          { "wxGridCellRenderer_Draw", (PyCFunction) _wrap_wxGridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS },
14299          { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS },
14300          { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS },
14301          { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS },
14302          { NULL, NULL }
14303 };
14304 #ifdef __cplusplus
14305 }
14306 #endif
14307 /*
14308  * This table is used by the pointer type-checker
14309  */
14310 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
14311     { "_wxEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxEvent},
14312     { "_wxEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxEvent},
14313     { "_wxEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxEvent},
14314     { "_wxEvent","_wxGridEvent",SwigwxGridEventTowxEvent},
14315     { "_signed_long","_long",0},
14316     { "_wxGridCellChoiceEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellChoiceEditor},
14317     { "_wxPrintQuality","_WXGRIDSELECTIONMODES",0},
14318     { "_wxPrintQuality","_wxCoord",0},
14319     { "_wxPrintQuality","_int",0},
14320     { "_wxPrintQuality","_signed_int",0},
14321     { "_wxPrintQuality","_unsigned_int",0},
14322     { "_wxPrintQuality","_wxWindowID",0},
14323     { "_wxPrintQuality","_uint",0},
14324     { "_wxPrintQuality","_EBool",0},
14325     { "_wxPrintQuality","_size_t",0},
14326     { "_wxPrintQuality","_time_t",0},
14327     { "_wxNotifyEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxNotifyEvent},
14328     { "_wxNotifyEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxNotifyEvent},
14329     { "_wxNotifyEvent","_wxGridEvent",SwigwxGridEventTowxNotifyEvent},
14330     { "_byte","_unsigned_char",0},
14331     { "_long","_unsigned_long",0},
14332     { "_long","_signed_long",0},
14333     { "_size_t","_WXGRIDSELECTIONMODES",0},
14334     { "_size_t","_wxCoord",0},
14335     { "_size_t","_wxPrintQuality",0},
14336     { "_size_t","_time_t",0},
14337     { "_size_t","_unsigned_int",0},
14338     { "_size_t","_int",0},
14339     { "_size_t","_wxWindowID",0},
14340     { "_size_t","_uint",0},
14341     { "_wxPanel","_wxGrid",SwigwxGridTowxPanel},
14342     { "_uint","_WXGRIDSELECTIONMODES",0},
14343     { "_uint","_wxCoord",0},
14344     { "_uint","_wxPrintQuality",0},
14345     { "_uint","_time_t",0},
14346     { "_uint","_size_t",0},
14347     { "_uint","_unsigned_int",0},
14348     { "_uint","_int",0},
14349     { "_uint","_wxWindowID",0},
14350     { "_wxChar","_char",0},
14351     { "_wxCommandEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxCommandEvent},
14352     { "_wxCommandEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxCommandEvent},
14353     { "_wxCommandEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxCommandEvent},
14354     { "_wxCommandEvent","_wxGridEvent",SwigwxGridEventTowxCommandEvent},
14355     { "_char","_wxChar",0},
14356     { "_wxGridCellStringRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellStringRenderer},
14357     { "_wxGridCellStringRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellStringRenderer},
14358     { "_wxGridCellStringRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellStringRenderer},
14359     { "_wxGridCellStringRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellStringRenderer},
14360     { "_wxGridCellStringRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellStringRenderer},
14361     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
14362     { "_wxGridTableBase","_wxGridStringTable",SwigwxGridStringTableTowxGridTableBase},
14363     { "_wxGridTableBase","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxGridTableBase},
14364     { "_EBool","_WXGRIDSELECTIONMODES",0},
14365     { "_EBool","_wxCoord",0},
14366     { "_EBool","_wxPrintQuality",0},
14367     { "_EBool","_signed_int",0},
14368     { "_EBool","_int",0},
14369     { "_EBool","_wxWindowID",0},
14370     { "_unsigned_long","_long",0},
14371     { "_WXGRIDSELECTIONMODES","_int",0},
14372     { "_WXGRIDSELECTIONMODES","_signed_int",0},
14373     { "_WXGRIDSELECTIONMODES","_unsigned_int",0},
14374     { "_WXGRIDSELECTIONMODES","_wxWindowID",0},
14375     { "_WXGRIDSELECTIONMODES","_uint",0},
14376     { "_WXGRIDSELECTIONMODES","_EBool",0},
14377     { "_WXGRIDSELECTIONMODES","_size_t",0},
14378     { "_WXGRIDSELECTIONMODES","_time_t",0},
14379     { "_WXGRIDSELECTIONMODES","_wxPrintQuality",0},
14380     { "_WXGRIDSELECTIONMODES","_wxCoord",0},
14381     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
14382     { "_signed_int","_WXGRIDSELECTIONMODES",0},
14383     { "_signed_int","_wxCoord",0},
14384     { "_signed_int","_wxPrintQuality",0},
14385     { "_signed_int","_EBool",0},
14386     { "_signed_int","_wxWindowID",0},
14387     { "_signed_int","_int",0},
14388     { "_wxGridCellEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellEditor},
14389     { "_wxGridCellEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellEditor},
14390     { "_wxGridCellEditor","_wxGridCellChoiceEditor",SwigwxGridCellChoiceEditorTowxGridCellEditor},
14391     { "_wxGridCellEditor","_wxGridCellBoolEditor",SwigwxGridCellBoolEditorTowxGridCellEditor},
14392     { "_wxGridCellEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellEditor},
14393     { "_wxGridCellEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellEditor},
14394     { "_wxGridCellEditor","_wxGridCellTextEditor",SwigwxGridCellTextEditorTowxGridCellEditor},
14395     { "_wxGridCellEditor","_wxPyGridCellEditor",SwigwxPyGridCellEditorTowxGridCellEditor},
14396     { "_WXTYPE","_short",0},
14397     { "_WXTYPE","_signed_short",0},
14398     { "_WXTYPE","_unsigned_short",0},
14399     { "_wxGridCellAttrProvider","_wxPyGridCellAttrProvider",SwigwxPyGridCellAttrProviderTowxGridCellAttrProvider},
14400     { "_unsigned_short","_WXTYPE",0},
14401     { "_unsigned_short","_short",0},
14402     { "_wxObject","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxObject},
14403     { "_wxObject","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxObject},
14404     { "_wxObject","_wxGridSizeEvent",SwigwxGridSizeEventTowxObject},
14405     { "_wxObject","_wxGridEvent",SwigwxGridEventTowxObject},
14406     { "_wxObject","_wxGrid",SwigwxGridTowxObject},
14407     { "_wxObject","_wxGridStringTable",SwigwxGridStringTableTowxObject},
14408     { "_wxObject","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxObject},
14409     { "_wxObject","_wxGridTableBase",SwigwxGridTableBaseTowxObject},
14410     { "_signed_short","_WXTYPE",0},
14411     { "_signed_short","_short",0},
14412     { "_wxScrolledWindow","_wxGrid",SwigwxGridTowxScrolledWindow},
14413     { "_unsigned_char","_byte",0},
14414     { "_unsigned_int","_WXGRIDSELECTIONMODES",0},
14415     { "_unsigned_int","_wxCoord",0},
14416     { "_unsigned_int","_wxPrintQuality",0},
14417     { "_unsigned_int","_time_t",0},
14418     { "_unsigned_int","_size_t",0},
14419     { "_unsigned_int","_uint",0},
14420     { "_unsigned_int","_wxWindowID",0},
14421     { "_unsigned_int","_int",0},
14422     { "_short","_WXTYPE",0},
14423     { "_short","_unsigned_short",0},
14424     { "_short","_signed_short",0},
14425     { "_wxWindowID","_WXGRIDSELECTIONMODES",0},
14426     { "_wxWindowID","_wxCoord",0},
14427     { "_wxWindowID","_wxPrintQuality",0},
14428     { "_wxWindowID","_time_t",0},
14429     { "_wxWindowID","_size_t",0},
14430     { "_wxWindowID","_EBool",0},
14431     { "_wxWindowID","_uint",0},
14432     { "_wxWindowID","_int",0},
14433     { "_wxWindowID","_signed_int",0},
14434     { "_wxWindowID","_unsigned_int",0},
14435     { "_int","_WXGRIDSELECTIONMODES",0},
14436     { "_int","_wxCoord",0},
14437     { "_int","_wxPrintQuality",0},
14438     { "_int","_time_t",0},
14439     { "_int","_size_t",0},
14440     { "_int","_EBool",0},
14441     { "_int","_uint",0},
14442     { "_int","_wxWindowID",0},
14443     { "_int","_unsigned_int",0},
14444     { "_int","_signed_int",0},
14445     { "_time_t","_WXGRIDSELECTIONMODES",0},
14446     { "_time_t","_wxCoord",0},
14447     { "_time_t","_wxPrintQuality",0},
14448     { "_time_t","_unsigned_int",0},
14449     { "_time_t","_int",0},
14450     { "_time_t","_wxWindowID",0},
14451     { "_time_t","_uint",0},
14452     { "_time_t","_size_t",0},
14453     { "_wxCoord","_WXGRIDSELECTIONMODES",0},
14454     { "_wxCoord","_int",0},
14455     { "_wxCoord","_signed_int",0},
14456     { "_wxCoord","_unsigned_int",0},
14457     { "_wxCoord","_wxWindowID",0},
14458     { "_wxCoord","_uint",0},
14459     { "_wxCoord","_EBool",0},
14460     { "_wxCoord","_size_t",0},
14461     { "_wxCoord","_time_t",0},
14462     { "_wxCoord","_wxPrintQuality",0},
14463     { "_wxGridCellRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellRenderer},
14464     { "_wxGridCellRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellRenderer},
14465     { "_wxGridCellRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellRenderer},
14466     { "_wxGridCellRenderer","_wxGridCellBoolRenderer",SwigwxGridCellBoolRendererTowxGridCellRenderer},
14467     { "_wxGridCellRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellRenderer},
14468     { "_wxGridCellRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellRenderer},
14469     { "_wxGridCellRenderer","_wxGridCellStringRenderer",SwigwxGridCellStringRendererTowxGridCellRenderer},
14470     { "_wxGridCellRenderer","_wxPyGridCellRenderer",SwigwxPyGridCellRendererTowxGridCellRenderer},
14471     { "_wxGridCellTextEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellTextEditor},
14472     { "_wxGridCellTextEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellTextEditor},
14473     { "_wxGridCellTextEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellTextEditor},
14474     { "_wxEvtHandler","_wxGrid",SwigwxGridTowxEvtHandler},
14475     { "_wxWindow","_wxGrid",SwigwxGridTowxWindow},
14476 {0,0,0}};
14477
14478 static PyObject *SWIG_globals;
14479 #ifdef __cplusplus
14480 extern "C"
14481 #endif
14482 SWIGEXPORT(void) initgridc() {
14483          PyObject *m, *d;
14484          SWIG_globals = SWIG_newvarlink();
14485          m = Py_InitModule("gridc", gridcMethods);
14486          d = PyModule_GetDict(m);
14487          PyDict_SetItemString(d,"wxGRID_VALUE_STRING", PyString_FromString("string"));
14488          PyDict_SetItemString(d,"wxGRID_VALUE_BOOL", PyString_FromString("bool"));
14489          PyDict_SetItemString(d,"wxGRID_VALUE_NUMBER", PyString_FromString("long"));
14490          PyDict_SetItemString(d,"wxGRID_VALUE_FLOAT", PyString_FromString("double"));
14491          PyDict_SetItemString(d,"wxGRID_VALUE_CHOICE", PyString_FromString("choice"));
14492          PyDict_SetItemString(d,"wxGRID_VALUE_TEXT", PyString_FromString("string"));
14493          PyDict_SetItemString(d,"wxGRID_VALUE_LONG", PyString_FromString("long"));
14494          PyDict_SetItemString(d,"cvar", SWIG_globals);
14495          SWIG_addvarlink(SWIG_globals,"wxGridNoCellCoords",_wrap_wxGridNoCellCoords_get, _wrap_wxGridNoCellCoords_set);
14496          SWIG_addvarlink(SWIG_globals,"wxGridNoCellRect",_wrap_wxGridNoCellRect_get, _wrap_wxGridNoCellRect_set);
14497          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_GET_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_GET_VALUES));
14498          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES));
14499          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_INSERTED));
14500          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_APPENDED));
14501          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_DELETED));
14502          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_INSERTED));
14503          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_APPENDED));
14504          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_DELETED));
14505          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_CLICK));
14506          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_CLICK));
14507          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_DCLICK));
14508          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_DCLICK));
14509          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_CLICK));
14510          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_CLICK));
14511          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_DCLICK));
14512          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_DCLICK));
14513          PyDict_SetItemString(d,"wxEVT_GRID_ROW_SIZE", PyInt_FromLong((long) wxEVT_GRID_ROW_SIZE));
14514          PyDict_SetItemString(d,"wxEVT_GRID_COL_SIZE", PyInt_FromLong((long) wxEVT_GRID_COL_SIZE));
14515          PyDict_SetItemString(d,"wxEVT_GRID_RANGE_SELECT", PyInt_FromLong((long) wxEVT_GRID_RANGE_SELECT));
14516          PyDict_SetItemString(d,"wxEVT_GRID_CELL_CHANGE", PyInt_FromLong((long) wxEVT_GRID_CELL_CHANGE));
14517          PyDict_SetItemString(d,"wxEVT_GRID_SELECT_CELL", PyInt_FromLong((long) wxEVT_GRID_SELECT_CELL));
14518          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_SHOWN));
14519          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_HIDDEN));
14520          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong((long) wxEVT_GRID_EDITOR_CREATED));
14521
14522     wxClassInfo::CleanUpClasses();
14523     wxClassInfo::InitializeClasses();
14524          PyDict_SetItemString(d,"wxGridCellAttr_Any", PyInt_FromLong((long) wxGridCellAttr::Any));
14525          PyDict_SetItemString(d,"wxGridCellAttr_Default", PyInt_FromLong((long) wxGridCellAttr::Default));
14526          PyDict_SetItemString(d,"wxGridCellAttr_Cell", PyInt_FromLong((long) wxGridCellAttr::Cell));
14527          PyDict_SetItemString(d,"wxGridCellAttr_Row", PyInt_FromLong((long) wxGridCellAttr::Row));
14528          PyDict_SetItemString(d,"wxGridCellAttr_Col", PyInt_FromLong((long) wxGridCellAttr::Col));
14529          PyDict_SetItemString(d,"wxGridCellAttr_Merged", PyInt_FromLong((long) wxGridCellAttr::Merged));
14530          PyDict_SetItemString(d,"wxGrid_wxGridSelectCells", PyInt_FromLong((long) wxGrid::wxGridSelectCells));
14531          PyDict_SetItemString(d,"wxGrid_wxGridSelectRows", PyInt_FromLong((long) wxGrid::wxGridSelectRows));
14532          PyDict_SetItemString(d,"wxGrid_wxGridSelectColumns", PyInt_FromLong((long) wxGrid::wxGridSelectColumns));
14533 {
14534    int i;
14535    for (i = 0; _swig_mapping[i].n1; i++)
14536         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
14537 }
14538 }